refactor(auth): 重构授权逻辑，优化会话管理和错误处理

- 将授权相关功能抽离到独立模块 authRedirect.js - 实现静默续期和请求重放机制 - 优化授权失败后的降级处理 - 统一管理页面跳转和路径保存逻辑 - 移除未使用的代码和组件

refactor(auth): 重构授权逻辑，优化会话管理和错误处理
- 将授权相关功能抽离到独立模块 authRedirect.js - 实现静默续期和请求重放机制 - 优化授权失败后的降级处理 - 统一管理页面跳转和路径保存逻辑 - 移除未使用的代码和组件
hookehuyr
Commit 6019b45e9cec67932ceab8536498405b05373495 6019b45e 1 parent ef79802c
Showing 4 changed files with 220 additions and 108 deletions
components.d.ts
src/pages/index/index.vue
src/utils/authRedirect.js
src/utils/request.js
--- a/components.d.ts
View file @6019b45
+++ b/components.d.ts
View file @6019b45
@@ -10,7 +10,6 @@ declare module 'vue' {
     NutButton: typeof import('@nutui/nutui-taro')['Button']
     NutCheckbox: typeof import('@nutui/nutui-taro')['Checkbox']
     NutCheckboxGroup: typeof import('@nutui/nutui-taro')['CheckboxGroup']
-    NutConfigProvider: typeof import('@nutui/nutui-taro')['ConfigProvider']
     NutDatePicker: typeof import('@nutui/nutui-taro')['DatePicker']
     NutInput: typeof import('@nutui/nutui-taro')['Input']
     NutPicker: typeof import('@nutui/nutui-taro')['Picker']
--- a/src/pages/index/index.vue
View file @6019b45
+++ b/src/pages/index/index.vue
View file @6019b45
@@ -45,29 +45,19 @@
 </template>
 <script setup>
-import { ref } from 'vue'
+import Taro, { useShareAppMessage } from '@tarojs/taro'
-import Taro, { useDidShow, useShareAppMessage } from '@tarojs/taro'
 // import { showSuccessToast, showFailToast } from 'vant'; // NutUI 或 Taro API
-import { billListAPI } from '@/api/index';
 import { useGo } from '@/hooks/useGo'
 import icon_1 from '@/assets/images/立即预约@2x.png'
-import icon_2 from '@/assets/images/预约记录@2x.png'
 import icon_3 from '@/assets/images/首页02@2x.png'
 import icon_4 from '@/assets/images/二维码icon.png'
 import icon_5 from '@/assets/images/我的01@2x.png'
-import icon_6 from '@/assets/images/luru@2x.png'
 const go = useGo();
 const toBooking = () => { // 跳转到预约须知
   go('/notice');
 }
-const toRecord = () => { // 跳转到预约记录
-  go('/bookingList');
-}
-const toSearch = () => { // 跳转到寺院录入
-  go('/search');
-}
 const toCode = () => { // 跳转到预约码
   Taro.redirectTo({
     url: '/pages/bookingCode/index'
@@ -79,12 +69,6 @@ const toMy = () => { // 跳转到我的
   })
 }
-useDidShow(async () => {
-  // TAG: 触发授权页面 (检查 session 或调用接口触发 401)
-  // 小程序中，request.js 拦截器会处理 401 跳转
-  await billListAPI({ page: 1, row_num: 1 });
-});
-
 useShareAppMessage(() => {
   return {
     title: '西园寺预约',
--- a/src/utils/authRedirect.js
View file @6019b45
+++ b/src/utils/authRedirect.js
View file @6019b45
 import Taro from '@tarojs/taro'
 import { routerStore } from '@/stores/router'
-import request from '@/utils/request'
+import BASE_URL from './config'
-
+
+/**
+ * 授权与回跳相关工具
+ * - 统一管理：保存来源页、静默授权、跳转授权页、授权后回跳
+ * - 约定：sessionid 存在于本地缓存 key 为 sessionid
+ * - 说明：refreshSession/silentAuth 使用单例 Promise，避免并发重复授权
+ */
+
+/**
+ * 获取当前页完整路径（含 query）
+ * @returns {string} 当前页路径，示例：pages/index/index?a=1
+ */
 export const getCurrentPageFullPath = () => {
-    const pages = getCurrentPages()
+    const pages = Taro.getCurrentPages()
     if (!pages || pages.length === 0) return ''
     const current_page = pages[pages.length - 1]
@@ -17,12 +28,21 @@ export const getCurrentPageFullPath = () => {
     return query_params ? `${route}?${query_params}` : route
 }
+/**
+ * 保存当前页路径（用于授权成功后回跳）
+ * @param {string} custom_path 自定义路径，不传则取当前页
+ * @returns {void}
+ */
 export const saveCurrentPagePath = (custom_path) => {
     const router = routerStore()
     const path = custom_path || getCurrentPageFullPath()
     router.add(path)
 }
+/**
+ * 判断是否需要授权
+ * @returns {boolean} true=需要授权，false=已存在 sessionid
+ */
 export const needAuth = () => {
     try {
         const sessionid = Taro.getStorageSync('sessionid')
@@ -33,71 +53,150 @@ export const needAuth = () => {
     }
 }
-export const silentAuth = async (on_success, on_error) => {
+let auth_promise = null
-    try {
-        if (!needAuth()) {
-            const result = { code: 1, msg: '已授权' }
-            if (on_success) on_success(result)
-            return result
-        }
-        Taro.showLoading({
+/**
-            title: '加载中...',
+ * 刷新会话：通过 Taro.login 获取 code，换取后端会话 cookie 并写入缓存
-            mask: true,
+ * - 被 request.js 的 401 拦截器调用，用于自动“静默续期 + 原请求重放”
-        })
+ * - 复用 auth_promise，防止多个接口同时 401 时并发触发多次登录
+ * @param {object} options 可选项
+ * @param {boolean} options.show_loading 是否展示 loading，默认 true
+ * @returns {Promise<{code:number,msg?:string,data?:any,cookie?:string}>} 后端返回 + cookie
+ */
+export const refreshSession = async (options) => {
+    const show_loading = options?.show_loading !== false
-        const login_result = await new Promise((resolve, reject) => {
+    // 已有授权进行中时，直接复用同一个 Promise
-            Taro.login({
+    if (auth_promise) return auth_promise
-                success: resolve,
+
-                fail: reject,
+    auth_promise = (async () => {
+        try {
+            if (show_loading) {
+                Taro.showLoading({
+                    title: '加载中...',
+                    mask: true,
+                })
+            }
+
+            // 调用微信登录获取临时 code
+            const login_result = await new Promise((resolve, reject) => {
+                Taro.login({
+                    success: resolve,
+                    fail: reject,
+                })
             })
-        })
-        if (!login_result || !login_result.code) {
+            if (!login_result || !login_result.code) {
-            throw new Error('获取微信登录code失败')
+                throw new Error('获取微信登录code失败')
-        }
+            }
-        const response = await request.post('/srv/?a=openid', {
+            const request_data = {
-            code: login_result.code,
+                code: login_result.code,
-        })
+            }
-        Taro.hideLoading()
+            // 开发环境可按需手动传 openid（仅用于本地联调）
+            if (process.env.NODE_ENV === 'development') {
+                // request_data.openid = 'h-008';
+                // request_data.openid = 'h-009';
+                // request_data.openid = 'h-010';
+                // request_data.openid = 'h-011';
+                // request_data.openid = 'h-012';
+                // request_data.openid = 'h-013';
+                // request_data.openid = 'oWbdFvkD5VtloC50wSNR9IWiU2q8';
+                // request_data.openid = 'oex8h5QZnZJto3ttvO6swSvylAQo';
+            }
-        if (!response?.data || response.data.code !== 1) {
+            if (process.env.NODE_ENV === 'production') {
-            const error_msg = response?.data?.msg || '授权失败'
+                // request_data.openid = 'h-013';
-            if (on_error) on_error(error_msg)
+            }
-            throw new Error(error_msg)
-        }
-        let cookie =
+            // 换取后端会话（服务端通过 Set-Cookie 返回会话信息）
-            (response.cookies && response.cookies[0]) ||
+            const response = await Taro.request({
-            response.header?.['Set-Cookie'] ||
+                url: `${BASE_URL}/srv/?a=openid&f=reserve&client_name=${encodeURIComponent('智慧西园寺')}`,
-            response.header?.['set-cookie']
+                method: 'POST',
+                data: request_data,
+            })
-        if (Array.isArray(cookie)) cookie = cookie[0]
+            if (!response?.data || response.data.code !== 1) {
+                throw new Error(response?.data?.msg || '授权失败')
+            }
-        if (!cookie) {
+            // 兼容小程序环境下 cookie 的不同字段位置
-            const error_msg = '授权失败：没有获取到有效的会话信息'
+            let cookie =
-            if (on_error) on_error(error_msg)
+                (response.cookies && response.cookies[0]) ||
-            throw new Error(error_msg)
+                response.header?.['Set-Cookie'] ||
-        }
+                response.header?.['set-cookie']
+
+            if (Array.isArray(cookie)) cookie = cookie[0]
+
+            if (!cookie) {
+                throw new Error('授权失败：没有获取到有效的会话信息')
+            }
-        Taro.setStorageSync('sessionid', cookie)
+            // 写入本地缓存：后续请求会从缓存取 sessionid 并带到请求头
+            Taro.setStorageSync('sessionid', cookie)
-        if (request?.defaults?.headers) {
+            return {
-            request.defaults.headers.cookie = cookie
+                ...response.data,
+                cookie,
+            }
+        } finally {
+            if (show_loading) {
+                Taro.hideLoading()
+            }
         }
+    })().finally(() => {
+        auth_promise = null
+    })
+
+    return auth_promise
+}
+
+const do_silent_auth = async (show_loading) => {
+    // 已有 sessionid 时直接视为已授权
+    if (!needAuth()) {
+        return { code: 1, msg: '已授权' }
+    }
-        if (on_success) on_success(response.data)
+    // 需要授权时，走刷新会话逻辑
-        return response.data
+    return await refreshSession({ show_loading })
+}
+
+/**
+ * 静默授权：用于启动阶段/分享页/授权页发起授权
+ * - 与 refreshSession 共用 auth_promise，避免并发重复调用
+ * @param {Function} on_success 成功回调
+ * @param {Function} on_error 失败回调（入参为错误文案）
+ * @param {object} options 可选项
+ * @param {boolean} options.show_loading 是否展示 loading，默认 true
+ * @returns {Promise<any>} 授权结果
+ */
+export const silentAuth = async (on_success, on_error, options) => {
+    const show_loading = options?.show_loading !== false
+
+    try {
+        // 未有授权进行中时才发起一次授权，并复用 Promise
+        if (!auth_promise) {
+            auth_promise = do_silent_auth(show_loading).finally(() => {
+                auth_promise = null
+            })
+        }
+        const result = await auth_promise
+        if (on_success) on_success(result)
+        return result
     } catch (error) {
-        Taro.hideLoading()
         const error_msg = error?.message || '授权失败，请稍后重试'
         if (on_error) on_error(error_msg)
         throw error
     }
 }
+/**
+ * 跳转到授权页（降级方案）
+ * - 会先保存回跳路径（默认当前页），授权成功后在 auth 页回跳
+ * @param {string} return_path 指定回跳路径
+ * @returns {void}
+ */
 export const navigateToAuth = (return_path) => {
     if (return_path) {
         saveCurrentPagePath(return_path)
@@ -105,11 +204,26 @@ export const navigateToAuth = (return_path) => {
         saveCurrentPagePath()
     }
-    Taro.navigateTo({
+    const pages = Taro.getCurrentPages()
-        url: '/pages/auth/index',
+    const current_page = pages[pages.length - 1]
+    const current_route = current_page?.route
+    if (current_route === 'pages/auth/index') {
+        return
+    }
+
+    // navigateTo 失败时（例如页面栈满），降级为 redirectTo
+    Taro.navigateTo({ url: '/pages/auth/index' }).catch(() => {
+        return Taro.redirectTo({ url: '/pages/auth/index' })
     })
 }
+/**
+ * 授权成功后回跳到来源页
+ * - 优先使用 routerStore 里保存的路径
+ * - 失败降级：redirectTo -> reLaunch
+ * @param {string} default_path 未保存来源页时的默认回跳路径
+ * @returns {Promise<void>}
+ */
 export const returnToOriginalPage = async (default_path = '/pages/index/index') => {
     const router = routerStore()
     const saved_path = router.url
@@ -147,10 +261,23 @@ export const returnToOriginalPage = async (default_path = '/pages/index/index') 
     }
 }
+/**
+ * 判断是否来自分享场景
+ * @param {object} options 页面 options
+ * @returns {boolean}
+ */
 export const isFromShare = (options) => {
     return options && (options.from_share === '1' || options.scene)
 }
+/**
+ * 分享页进入时的授权处理
+ * - 来自分享且未授权：保存当前页路径，授权成功后回跳
+ * - 授权失败：返回 false，由调用方决定是否继续降级处理
+ * @param {object} options 页面 options
+ * @param {Function} callback 授权成功后的继续逻辑
+ * @returns {Promise<boolean>} true=已处理且可继续，false=授权失败
+ */
 export const handleSharePageAuth = async (options, callback) => {
     if (!needAuth()) {
         if (typeof callback === 'function') callback()
@@ -167,16 +294,21 @@ export const handleSharePageAuth = async (options, callback) => {
                 if (typeof callback === 'function') callback()
             },
             () => {
-                Taro.navigateTo({ url: '/pages/auth/index' })
+                // Taro.navigateTo({ url: '/pages/auth/index' })
             }
         )
         return true
     } catch (error) {
-        Taro.navigateTo({ url: '/pages/auth/index' })
+        // Taro.navigateTo({ url: '/pages/auth/index' })
         return false
     }
 }
+/**
+ * 为路径追加分享标记
+ * @param {string} path 原路径
+ * @returns {string} 追加后的路径
+ */
 export const addShareFlag = (path) => {
     const separator = path.includes('?') ? '&' : '?'
     return `${path}${separator}from_share=1`
--- a/src/utils/request.js
View file @6019b45
+++ b/src/utils/request.js
View file @6019b45
 /*
  * @Date: 2022-09-19 14:11:06
  * @LastEditors: hookehuyr hookehuyr@gmail.com
- * @LastEditTime: 2026-01-07 21:44:54
+ * @LastEditTime: 2026-01-08 16:27:50
  * @FilePath: /xyxBooking-weapp/src/utils/request.js
  * @Description: 简单axios封装，后续按实际处理
  */
@@ -10,7 +10,7 @@ import axios from 'axios-miniprogram';
 import Taro from '@tarojs/taro'
 // import qs from 'qs'
 // import { strExist } from './tools'
-import { routerStore } from '@/stores/router'
+import { refreshSession, saveCurrentPagePath, navigateToAuth } from './authRedirect'
 // import { ProgressStart, ProgressEnd } from '@/components/axios-progress/progress';
 // import store from '@/store'
@@ -30,25 +30,6 @@ const getSessionId = () => {
   }
 };
-const getCurrentPageFullPath = () => {
-  try {
-    const pages = Taro.getCurrentPages()
-    if (!pages || pages.length === 0) return ''
-
-    const currentPage = pages[pages.length - 1]
-    const route = currentPage.route
-    const options = currentPage.options || {}
-
-    const queryParams = Object.keys(options)
-      .map(key => `${key}=${encodeURIComponent(options[key])}`)
-      .join('&')
-
-    return queryParams ? `${route}?${queryParams}` : route
-  } catch (error) {
-    return ''
-  }
-}
-
 // const isPlainObject = (value) => {
 //   if (value === null || typeof value !== 'object') return false
 //   return Object.prototype.toString.call(value) === '[object Object]'
@@ -114,33 +95,49 @@ service.interceptors.request.use(
 // response interceptor
 service.interceptors.response.use(
   /**
-   * If you want to get http information such as headers or status
+   * 响应拦截器说明
-   * Please return  response => response
+   * - 这里统一处理后端自定义 code（例如 401 未授权）
+   * - 如需拿到 headers/status 等原始信息，直接返回 response 即可
    */
-
+  async response => {
-  /**
-   * Determine the request status by custom code
-   * Here is just an example
-   * You can also judge the status by HTTP Status Code
-   */
-  response => {
     const res = response.data
     // 401 未授权处理
     if (res.code === 401) {
-        // 跳转到授权页
+        const config = response?.config || {}
-        // 避免死循环，如果已经在 auth 页则不跳
+        /**
+         * 避免死循环/重复授权：
+         * - __is_auth_request：本次请求就是“换取会话”的授权请求，不应再次触发刷新
+         * - __is_retry：本次请求是 401 后的重试请求，如果仍 401，不再继续重试
+         */
+        if (config.__is_auth_request || config.__is_retry) {
+          return response
+        }
+
+        /**
+         * 记录来源页：用于授权成功后回跳
+         * - 避免死循环：如果已经在 auth 页则不重复记录/跳转
+         */
         const pages = Taro.getCurrentPages();
         const currentPage = pages[pages.length - 1];
         if (currentPage && currentPage.route !== 'pages/auth/index') {
-            const router = routerStore()
+            saveCurrentPagePath()
-            const currentPath = getCurrentPageFullPath()
+        }
-            if (currentPath) {
+
-              router.add(currentPath)
+        try {
-            }
+          // 优先走静默续期：成功后重放原请求
-            // Taro.navigateTo({ url: '/pages/auth/index' });
+          await refreshSession()
+          const retry_config = { ...config, __is_retry: true }
+          return await service(retry_config)
+        } catch (error) {
+          // 静默续期失败：降级跳转到授权页（由授权页完成授权并回跳）
+          const pages_retry = Taro.getCurrentPages();
+          const current_page_retry = pages_retry[pages_retry.length - 1];
+          if (current_page_retry && current_page_retry.route !== 'pages/auth/index') {
+            navigateToAuth()
+          }
+          return response
         }
-        return response; // 返回 response 以便业务代码处理（或者这里 reject）
     }
     if (['预约ID不存在'].includes(res.msg)) {