devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

vue3 ---- 递归组件生成menu菜单 && 路由守卫鉴权_el-menu-item onmouseenter 箭头函数

作者：羊村懒王 | 2024-03-20 10:08:00

赞

踩

el-menu-item onmouseenter 箭头函数

目录

递归组件​

 el-menu

父组件

子组件

路由 

Vue路由守卫实现登录鉴权

全局守卫

路由独享的守卫

组件内的守卫

完整的导航解析流程

菜单权限

按钮权限

 对于一些有规律的DOM结构，如果我们再一遍遍的编写同样的代码，显然代码是比较繁琐和不科学的，而且自己的工作量会大大增加，

那么有没有一种方法来解决这个问题呢？

答案是肯定的，我们可以通过 递归 方式来生成这个结构，当然在 Vue 模板中也是可以实现的，我们可以在 Vue 的组件中调用自己本身，这样就能达到目的。

当然，在 Vue 中，组件可以递归的调用本身，但是有一些条件：

  • 该组件一定要有 name 属性
  • 要确保递归的调用有终止条件，防止内存溢出

递归组件​

一个单文件组件可以通过它的文件名被其自己所引用。例如：名为 FooBar.vue 的组件可以在其模板中用 <FooBar/> 引用它自己。

 el-menu

导航菜单默认为垂直模式，通过将 mode 属性设置为 horizontal 来使导航菜单变更为水平模式。 另外，在菜单中通过 sub-menu 组件可以生成二级菜单。 Menu 还提供了background-color、text-color和active-text-color，分别用于设置菜单的背景色、菜单的文字颜色和当前激活菜单的文字颜色。

collapse是否水平折叠收起菜单（仅在 mode 为 vertical 时可用）boolean—false
background-color菜单的背景颜色（十六进制格式）（已被废弃，使用--bg-color）string—#ffffff
text-color文字颜色（十六进制格式）（已被废弃，使用--text-color）string—#303133
active-text-color活动菜单项的文本颜色（十六进制格式）（已被废弃，使用--active-color）string—#409EFF
default-active页面加载时默认激活菜单的 indexstring——
index唯一标志string——
  1.  
  2. <template>
  3.   <el-menu
  4.     :default-active="activeIndex"
  5.     class="el-menu-demo"
  6.     mode="horizontal"
  7.     :ellipsis="false"
  8.     @select="handleSelect"
  9.   >
  10.     <el-menu-item index="0">LOGO</el-menu-item>
  11.     <div class="flex-grow" />
  12.     <el-menu-item index="1">Processing Center</el-menu-item>
  13.     <el-sub-menu index="2">
  14.       <template #title>Workspace</template>
  15.       <el-menu-item index="2-1">item one</el-menu-item>
  16.       <el-menu-item index="2-2">item two</el-menu-item>
  17.       <el-menu-item index="2-3">item three</el-menu-item>
  18.       <el-sub-menu index="2-4">
  19.         <template #title>item four</template>
  20.         <el-menu-item index="2-4-1">item one</el-menu-item>
  21.         <el-menu-item index="2-4-2">item two</el-menu-item>
  22.         <el-menu-item index="2-4-3">item three</el-menu-item>
  23.       </el-sub-menu>
  24.     </el-sub-menu>
  25.   </el-menu>
  26. </template>
  27.  
  28. <script lang="ts" setup>
  29. import { ref } from 'vue'
  30.  
  31. const activeIndex = ref('1')
  32. const handleSelect = (key: string, keyPath: string[]) => {
  33.   console.log(key, keyPath)
  34. }
  35. </script>
  36.  
  37. <style>
  38. .flex-grow {
  39.   flex-grow: 1;
  40. }
  41. </style>

父组件

  1.       <!-- 导航菜单 -->
  2.       <el-scrollbar class="scrollbar">
  3.         <el-menu
  4.           background-color="#001529"
  5.           text-color="white"
  6.           active-text-color="yellowgreen"
  7.           :default-active="route.path"
  8.           :collapse="SettingStore.fold ? true : false"
  9.         >
  10.           <Menu :menuList="UserStore.menuRouter"></Menu>
  11.         </el-menu>
  12.       </el-scrollbar>

子组件

必须要有name

要确保递归的调用有终止条件，防止内存溢出

  1. <template>
  2.   <template v-for="item in menuList" :key="item.path">
  3.     <!-- 没有子集 -->
  4.     <templatem v-if="!item.children">
  5.       <el-menu-item
  6.         :index="item.path"
  7.         v-if="!item.meta.hidden"
  8.         @click="goRoute"
  9.       >
  10.         <el-icon>
  11.           <component :is="item.meta.icon"></component>
  12.         </el-icon>
  13.         <template #title>
  14.           <span>{{ item.meta.title }}</span>
  15.         </template>
  16.       </el-menu-item>
  17.     </templatem>
  18.     <!-- 只有一个子集 -->
  19.     <template v-if="item.children && item.children.length == 1">
  20.       <el-menu-item
  21.         @click="goRoute"
  22.         :index="item.children[0].path"
  23.         v-if="!item.children[0].meta.hidden"
  24.       >
  25.         <el-icon>
  26.           <component :is="item.children[0].meta.icon"></component>
  27.         </el-icon>
  28.         <template #title>
  29.           <span>{{ item.children[0].meta.title }}</span>
  30.         </template>
  31.       </el-menu-item>
  32.     </template>
  33.  
  34.     <!-- 多个子集 -->
  35.     <el-sub-menu
  36.       :index="item.path"
  37.       v-if="item.children && item.children.length > 1"
  38.     >
  39.       <template #title>
  40.         <el-icon>
  41.           <component :is="item.meta.icon"></component>
  42.         </el-icon>
  43.         <span>{{ item.meta.title }}</span>
  44.       </template>
  45.       <Menu :menuList="item.children"></Menu>
  46.     </el-sub-menu>
  47.   </template>
  48. </template>
  49.  
  50. <script lang="ts" setup>
  51. import { useRouter } from 'vue-router'
  52. const router = useRouter()
  53. defineProps(['menuList'])
  54. const goRoute = (e: any) => {
  55.   console.log(e.index)
  56.   router.push(e.index)
  57. }
  58. </script>
  59. <script lang="ts">
  60. export default {
  61.   name: 'Menu',
  62. }
  63. </script>
  64.  
  65. <style scoped></style>

路由 

layout 布局组件

title:菜单标题

hidden: true,代表路由标题在菜单中是否隐藏 true:隐藏 false:不隐藏

icon: 'Promotion', 菜单文字左侧的图标,支持element-plus全部图标

  1. //对外暴露配置路由(常量路由):全部用户都可以访问到的路由
  2. export const constantRoute = [
  3.   {
  4.     //登录
  5.     path: '/login',
  6.     component: () => import('@/views/login/index.vue'),
  7.     name: 'login',
  8.     meta: {
  9.       title: '登录', //菜单标题
  10.       hidden: true, //代表路由标题在菜单中是否隐藏  true:隐藏 false:不隐藏
  11.       icon: 'Promotion', //菜单文字左侧的图标,支持element-plus全部图标
  12.     },
  13.   },
  14.   {
  15.     //登录成功以后展示数据的路由
  16.     path: '/',
  17.     component: () => import('@/layout/index.vue'),
  18.     name: 'layout',
  19.     meta: {
  20.       title: '',
  21.       hidden: false,
  22.       icon: '',
  23.     },
  24.     redirect: '/home',
  25.     children: [
  26.       {
  27.         path: '/home',
  28.         component: () => import('@/views/home/index.vue'),
  29.         meta: {
  30.           title: '首页',
  31.           hidden: false,
  32.           icon: 'HomeFilled',
  33.         },
  34.       },
  35.     ],
  36.   },
  37.   {
  38.     //404
  39.     path: '/404',
  40.     component: () => import('@/views/404/index.vue'),
  41.     name: '404',
  42.     meta: {
  43.       title: '404',
  44.       hidden: true,
  45.       icon: 'DocumentDelete',
  46.     },
  47.   },
  48.   {
  49.     path: '/screen',
  50.     component: () => import('@/views/screen/index.vue'),
  51.     name: 'Screen',
  52.     meta: {
  53.       hidden: false,
  54.       title: '数据大屏',
  55.       icon: 'Platform',
  56.     },
  57.   },
  58. ]
  59.  
  60. //异步路由
  61. export const asnycRoute = [
  62.   {
  63.     path: '/acl',
  64.     component: () => import('@/layout/index.vue'),
  65.     name: 'Acl',
  66.     meta: {
  67.       title: '权限管理',
  68.       icon: 'Lock',
  69.     },
  70.     redirect: '/acl/user',
  71.     children: [
  72.       {
  73.         path: '/acl/user',
  74.         component: () => import('@/views/acl/user/index.vue'),
  75.         name: 'User',
  76.         meta: {
  77.           title: '用户管理',
  78.           icon: 'User',
  79.         },
  80.       },
  81.       {
  82.         path: '/acl/role',
  83.         component: () => import('@/views/acl/role/index.vue'),
  84.         name: 'Role',
  85.         meta: {
  86.           title: '角色管理',
  87.           icon: 'UserFilled',
  88.         },
  89.       },
  90.       {
  91.         path: '/acl/permission',
  92.         component: () => import('@/views/acl/permission/index.vue'),
  93.         name: 'Permission',
  94.         meta: {
  95.           title: '菜单管理',
  96.           icon: 'Monitor',
  97.         },
  98.       },
  99.     ],
  100.   },
  101.   {
  102.     path: '/product',
  103.     component: () => import('@/layout/index.vue'),
  104.     name: 'Product',
  105.     meta: {
  106.       title: '商品管理',
  107.       icon: 'Goods',
  108.     },
  109.     redirect: '/product/trademark',
  110.     children: [
  111.       {
  112.         path: '/product/trademark',
  113.         component: () => import('@/views/product/trademark/index.vue'),
  114.         name: 'Trademark',
  115.         meta: {
  116.           title: '品牌管理',
  117.           icon: 'ShoppingCartFull',
  118.         },
  119.       },
  120.       {
  121.         path: '/product/attr',
  122.         component: () => import('@/views/product/attr/index.vue'),
  123.         name: 'Attr',
  124.         meta: {
  125.           title: '属性管理',
  126.           icon: 'ChromeFilled',
  127.         },
  128.       },
  129.       {
  130.         path: '/product/spu',
  131.         component: () => import('@/views/product/spu/index.vue'),
  132.         name: 'Spu',
  133.         meta: {
  134.           title: 'SPU管理',
  135.           icon: 'Calendar',
  136.         },
  137.       },
  138.       {
  139.         path: '/product/sku',
  140.         component: () => import('@/views/product/sku/index.vue'),
  141.         name: 'Sku',
  142.         meta: {
  143.           title: 'SKU管理',
  144.           icon: 'Orange',
  145.         },
  146.       },
  147.     ],
  148.   },
  149. ]
  150.  
  151. //任意路由
  152. export const anyRoute = {
  153.   //任意路由
  154.   path: '/:pathMatch(.*)*',
  155.   redirect: '/404',
  156.   name: 'Any',
  157.   meta: {
  158.     title: '任意路由',
  159.     hidden: true,
  160.     icon: 'DataLine',
  161.   },
  162. }

Vue路由守卫实现登录鉴权

一.路由守卫就是：
比如说，当点击商城的购物车的时候，需要判断一下是否登录，如果没有登录，就跳转到登录页面，如果登陆了，就跳转到购物车页面，相当于有一个守卫在安检

路由守卫有三种：
1：全局钩子
2：独享守卫（单个路由里面的钩子
3：组件内守卫
每个守卫方法接收三个参数：

①to: Route: 即将要进入的目标路由对象（to是一个对象，是将要进入的路由对象，可以用to.path调用路由对象中的属性）

②from: Route: 当前导航正要离开的路由

③next: Function: 这是一个必须需要调用的方法，执行效果依赖 next 方法的调用参数。
 

全局守卫

全局前置守卫beforeEach

在路由跳转前触发，参数包括to，from，next（参数会单独介绍）三个，这个钩子作用主要是用于登录验证，也就是路由还没跳转提前告知，以免跳转了再通知就为时已晚。

全局解析守卫beforeResolve(2.5.0 新增)

在导航被确认之前，同时在所有组件内守卫和异步路由组件被解析之后，解析守卫就被调用

全局后置钩子afterEach

全局后置钩子不会接受 next 函数也不会改变导航本身

  1. //路由鉴权:鉴权,项目当中路由能不能被的权限的设置(某一个路由什么条件下可以访问、什么条件下不可以访问)
  2. import router from '@/router'
  3. import setting from './setting'
  4. //@ts-ignore
  5. import nprogress from 'nprogress'
  6. //引入进度条样式
  7. import 'nprogress/nprogress.css'
  8. nprogress.configure({ showSpinner: false })
  9. //获取用户相关的小仓库内部token数据,去判断用户是否登录成功
  10. import useUserStore from './store/modules/user'
  11. import pinia from './store'
  12. const userStore = useUserStore(pinia)
  13. //全局守卫:项目当中任意路由切换都会触发的钩子
  14. //全局前置守卫
  15. router.beforeEach(async (to: any, from: any, next: any) => {
  16.   document.title = `${setting.title} - ${to.meta.title}`
  17.   //to:你将要访问那个路由
  18.   //from:你从来个路由而来
  19.   //next:路由的放行函数
  20.   nprogress.start()
  21.   //获取token,去判断用户登录、还是未登录
  22.   const token = userStore.token
  23.   //获取用户名字
  24.   const username = userStore.username
  25.   //用户登录判断
  26.   if (token) {
  27.     //登录成功,访问login,不能访问,指向首页
  28.     if (to.path == '/login') {
  29.       next({ path: '/' })
  30.     } else {
  31.       //登录成功访问其余六个路由(登录排除)
  32.       //有用户信息
  33.       if (username) {
  34.         //放行
  35.         next()
  36.       } else {
  37.         //如果没有用户信息,在守卫这里发请求获取到了用户信息再放行
  38.         try {
  39.           //获取用户信息
  40.           await userStore.userInfo()
  41.           //放行
  42.           //万一:刷新的时候是异步路由,有可能获取到用户信息、异步路由还没有加载完毕,出现空白的效果
  43.           next({ ...to })
  44.         } catch (error) {
  45.           //token过期:获取不到用户信息了
  46.           //用户手动修改本地存储token
  47.           //退出登录->用户相关的数据清空
  48.           await userStore.userLogout()
  49.           next({ path: '/login', query: { redirect: to.path } })
  50.         }
  51.       }
  52.     }
  53.   } else {
  54.     //用户未登录判断
  55.     if (to.path == '/login') {
  56.       next()
  57.     } else {
  58.       next({ path: '/login', query: { redirect: to.path } })
  59.     }
  60.   }
  61. })
  62. //全局后置守卫
  63. router.afterEach((to: any, from: any) => {
  64.   nprogress.done()
  65. })
  66.  
  67. //第一个问题:任意路由切换实现进度条业务 ---nprogress
  68. //第二个问题:路由鉴权(路由组件访问权限的设置)
  69. //全部路由组件:登录|404|任意路由|首页|数据大屏|权限管理(三个子路由)|商品管理(四个子路由)
  70.  
  71. //用户未登录:可以访问login,其余六个路由不能访问(指向login)
  72. //用户登录成功:不可以访问login[指向首页],其余的路由可以访问

路由独享的守卫

指在单个路由配置的时候也可以设置的钩子函数

beforeEnter

  1.     {
  2.         path: '/',
  3.         name: 'Home',
  4.         component: () => import('../views/Home.vue'),
  5.         meta: { isAuth: true },
  6.         beforeEnter: (to, from, next) => {
  7.             if (to.meta.isAuth) { //判断是否需要授权
  8.                 if (localStorage.getItem('school') === 'qinghuadaxue') {
  9.                     next()  //放行
  10.                 } else {
  11.                     alert('抱歉，您无权限查看！')
  12.                 }
  13.             } else {
  14.                 next()  //放行
  15.             }
  16.         }
  17.     },

组件内的守卫

beforeRouteEnter

beforeRouteEnter 守卫不能访问 this，因为守卫在导航确认前被调用，因此即将登场的新组件还没被创建。

注意：beforeRouteEnter 是支持给 next 传递回调的唯一守卫。对于 beforeRouteUpdate 和 beforeRouteLeave 来说，this 已经可用了，所以不支持传递回调，因为没有必要了。

  1.  
  2. //通过路由规则，进入该组件时被调用
  3. beforeRouteEnter(to,from,next) {
  4.   if(toString.meta.isAuth){
  5.     if(localStorage.getTime('school')==='qinghuadaxue'){
  6.       next()
  7.     }else{
  8.       alert('学校名不对，无权限查看！')
  9.     }
  10.   } else{
  11.     next()
  12.   }
  13. },

beforeRouteUpdate(2.2 新增)

这个守卫主要是路由复用时被调用，即在当前页面跳转当前页面，会走该守卫，而不会从头走路由钩子函数。

  1.   beforeRouteUpdate (to, from, next) {
  2.     // 在当前路由改变，但是该组件被复用时调用
  3.     // 举例来说，对于一个带有动态参数的路径 /foo/:id，在 /foo/1 和 /foo/2 之间跳转的时候，
  4.     // 由于会渲染同样的 Foo 组件，因此组件实例会被复用。而这个钩子就会在这个情况下被调用。
  5.     // 可以访问组件实例 `this`
  6.   }

beforeRouteLeave

这个离开守卫通常用来禁止用户在还未保存修改前突然离开。该导航可以通过 next(false) 来取消。

  1.  beforeRouteLeave (to, from, next) {
  2.     // 导航离开该组件的对应路由时调用
  3.     // 可以访问组件实例 `this`
  4.   }

完整的导航解析流程

  • 导航被触发。
  • 在失活的组件里调用 beforeRouteLeave 守卫。(组件内守卫，离开组件)
  • 调用全局的 beforeEach 守卫。（全局前置守卫）
  • 在重用的组件里调用 beforeRouteUpdate 守卫 (2.2+)。（组件内守卫，组件被复用）
  • 在路由配置里调用 beforeEnter。（组件内守卫）
  • 解析异步路由组件。
  • 在被激活的组件里调用 beforeRouteEnter。（组件内守卫，进入组件）
  • 调用全局的 beforeResolve 守卫 (2.5+)。（导航被确认前，组件内路由被加载完成）
  • 导航被确认。
  • 调用全局的 afterEach 钩子。（全局后置守卫）
  • 触发 DOM 更新。
  • 调用 beforeRouteEnter 守卫中传给 next 的回调函数，创建好的组件实例会作为回调函数的参数传入。（组件内守卫，进入组件）

菜单权限

通过后端接口返回的用户权限和之前前端写的异步路由的每一个页面所需要的权限做匹配，最后返回一个该用户能够访问路由有哪些。 addRoutes动态设置成功的路由表

这里还有一个小hack的地方，就是router.addRoutes之后的next()可能会失效，因为可能next()的时候路由并没有完全add完成，好在查阅文档发现

这样我们就可以简单的通过next(to)巧妙的避开之前的那个问题了。这行代码重新进入router.beforeEach这个钩子，这时候再通过next()来释放钩子，就能确保所有的路由都已经挂在完成了。

使用 lodash对异步路由表进行深克隆，避免过滤之后影响路由表的完整

  1. import { defineStore } from 'pinia'
  2. import type { loginFormData, loginResponseData } from '@/api/type'
  3. import { reqLogin, reqUserInfo, reqLogout } from '@/api/user'
  4. import { ref, Ref } from 'vue'
  5. import { constanRouter, asnycRoute, anyRoute } from '@/router/routes'
  6. import type { RouteRecordRaw } from 'vue-router'
  7. import { SET_TOKEN, GET_TOKEN, REMOVE_TOKEN } from '@/utils/token'
  8. import router from '@/router'
  9. //@ts-expect-error
  10. import cloneDeep from 'lodash/cloneDeep'
  11. export const useUserStore = defineStore('user', () => {
  12.   const token: Ref<string> = ref(GET_TOKEN() as string)
  13.   // 仓库存储生成菜单需要的数组
  14.   let menuRouter: Ref<RouteRecordRaw[]> = ref(constanRouter)
  15.   let buttons: Ref<string[]> = ref([])
  16.   const username: Ref<string> = ref('')
  17.   const avatar: Ref<string> = ref('')
  18.   // 过滤异步路由
  19.   const filterAsyncRoute = (asnycRoute: any, routes: any) => {
  20.     return asnycRoute.filter((item: any) => {
  21.       if (routes.includes(item.name)) {
  22.         if (item.children && item.children.length > 0) {
  23.           item.children = filterAsyncRoute(item.children, routes)
  24.         }
  25.         return true
  26.       }
  27.     })
  28.   }
  29.   //登录
  30.   const userLogin = async (data: loginFormData) => {
  31.     console.log(data)
  32.     let res: loginResponseData = await reqLogin(data)
  33.     console.log(res)
  34.     if (res.code === 200) {
  35.       token.value = res.data as string
  36.       SET_TOKEN(res.data as string)
  37.       return 'ok'
  38.     } else {
  39.       return Promise.reject(new Error(res.data))
  40.     }
  41.   }
  42.   // 获取用户信息
  43.   const userInfo = async () => {
  44.     let res = await reqUserInfo()
  45.     // console.log(res)
  46.     if (res.code === 200) {
  47.       console.log('-------')
  48.       username.value = res.data.name
  49.       avatar.value = res.data.avatar
  50.       buttons.value = res.data.buttons
  51.       // 异步路由
  52.       const userAsyncRoute = filterAsyncRoute(
  53.         cloneDeep(asnycRoute),
  54.         res.data.routes,
  55.       )
  56.       //菜单需要的数据整理完毕
  57.       menuRouter.value = [...constanRouter, ...anyRoute, ...userAsyncRoute]
  58.       //目前路由器管理的只有常量路由:用户计算完毕异步路由、任意路由动态追加
  59.       console.log(menuRouter);
  60.       [...userAsyncRoute, anyRoute].forEach((route: any) => {
  61.         router.addRoute(route)
  62.       })
  63.  
  64.       return 'ok'
  65.     } else {
  66.       return Promise.reject('获取用户信息失败')
  67.     }
  68.   }
  69.   // 退出登录
  70.   const userlogout = async () => {
  71.     let res = await reqLogout()
  72.     if (res.code === 200) {
  73.       token.value = ''
  74.       username.value = ''
  75.       avatar.value = ''
  76.       REMOVE_TOKEN()
  77.       return 'ok'
  78.     } else {
  79.       return Promise.reject(res.message)
  80.     }
  81.   }
  82.  
  83.   return {
  84.     userLogin,
  85.     token,
  86.     menuRouter,
  87.     userInfo,
  88.     username,
  89.     avatar,
  90.     userlogout,
  91.     buttons,
  92.   }
  93. })

按钮权限

封装了一个全局自定义指令权限，能简单快速的实现按钮级别的权限判断。

实现步骤：

我们登录成功之后，处理接口返回数据的时候，就存储了用户权限按钮数组buttons，

进行封装，项目根目录下新建一个directive文件夹 =》has.ts 

主要思路就是用户没有这个按钮权限的话，隐藏按钮。

  1. import { useUserStore } from '@/store/user'
  2.  
  3. export const isHasButton = (app: any) => {
  4.   //获取对应的用户仓库
  5.   //全局自定义指令:实现按钮的权限
  6.   app.directive('has', {
  7.     //代表使用这个全局自定义指令的DOM|组件挂载完毕的时候会执行一次
  8.     mounted(el: any, options: any) {
  9.       let userStore = useUserStore()
  10.       console.log(el, '----------')
  11.       //自定义指令右侧的数值:如果在用户信息buttons数组当中没有
  12.       //从DOM树上干掉
  13.       if (!userStore.buttons.includes(options.value)) {
  14.         el.parentNode.removeChild(el)
  15.       }
  16.     },
  17.   })
  18. }

main.ts中注册为全局指令

  1. //引入自定义指令文件
  2. import { isHasButton } from '@/directive/has'
  3. isHasButton(app)

页面中使用

  1.       <el-button
  2.         type="primary"
  3.         size="default"
  4.         @click="addUser"
  5.         v-has="`btn.User.add`"
  6.       >
  7.         添加用户
  8.       </el-button>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/272557
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号