Vue3项目实战:如何用axios拦截器优雅处理全局错误和Loading效果

让你的网站从http免费升级为https 一、问题 让网站(http://www.example.com )支持 https 协议,能正常访问( https://www.example.com)这个链接。 二、解决方案 https 其实就是通过 ca 证书,对服务器和域名进行实名认证。这里使用公益组织 Let's Encrypt 提供的工具 certbot 免费生成 ca 证书。 1、服务器环境: Ubuntu:服务器操作系统; nginx:用于部署运行网站的服务器; www.example.com :经过备案且能正常解析到服务 阅读详情

Vue3实战:用Axios拦截器构建企业级请求管理与Loading控制体系

在Vue3项目中,网络请求管理一直是开发体验的关键环节。每次发起请求时,开发者都需要面对重复的Loading状态控制、统一的错误处理、Token注入等繁琐问题。当项目规模扩大,这种重复劳动不仅降低开发效率,还容易导致代码不一致和维护困难。

我最近重构了一个中型后台管理系统,发现项目中存在十几个不同的Loading实现方式,错误提示也五花八门。这种混乱不仅影响用户体验,还给后续功能迭代埋下了隐患。经过系统性的重构,我总结出了一套基于Axios拦截器的完整解决方案,能够优雅地处理全局错误和Loading效果,同时支持复杂的并发请求场景。

这篇文章将分享我在实际项目中验证过的完整实现方案,适合已经熟悉Vue3和Axios基础用法的中级开发者。我们将从零开始构建一个可复用的请求管理模块,涵盖拦截器设计、Loading状态管理、错误处理策略以及并发请求优化等核心内容。

1. 构建企业级Axios实例与基础拦截器

1.1 创建可配置的Axios实例

在Vue3项目中,我通常会在src/utils目录下创建专门的请求管理模块。首先安装必要的依赖:

npm install axios

接下来创建基础的Axios实例配置文件。这里的关键是设计一个高度可配置的实例,而不是简单的默认配置:

// src/utils/request.ts
import axios, { 
  AxiosInstance, 
  AxiosRequestConfig, 
  AxiosResponse,
  InternalAxiosRequestConfig
} from 'axios'

// 定义请求配置接口
export interface RequestConfig extends AxiosRequestConfig {
  // 是否显示全局Loading
  showLoading?: boolean
  // 是否显示错误提示
  showError?: boolean
  // 自定义错误处理函数
  customErrorHandler?: (error: any) => void
  // 请求重试次数
  retryCount?: number
  // 请求重试延迟(毫秒)
  retryDelay?: number
}

// 创建默认配置
const defaultConfig: RequestConfig = {
  baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
  timeout: 15000,
  headers: {
    'Content-Type': 'application/json;charset=utf-8'
  },
  showLoading: true,
  showError: true,
  retryCount: 0,
  retryDelay: 1000
}

// 创建Axios实例
const createAxiosInstance = (config: RequestConfig = {}): AxiosInstance => {
  const instance = axios.create({
    ...defaultConfig,
    ...config
  })
  
  return instance
}

// 导出默认实例
const request = createAxiosInstance()

export { request, createAxiosInstance, type RequestConfig }

这种设计模式的优势在于:

  • 配置优先级明确:实例配置 > 默认配置
  • 类型安全:完整的TypeScript支持
  • 可扩展性:可以轻松添加新的配置项
  • 多实例支持:不同业务模块可以使用不同的配置

1.2 实现请求拦截器的核心逻辑

请求拦截器是处理请求前逻辑的关键位置。在我的实践中,拦截器需要处理以下几个核心任务:

// 继续在src/utils/request.ts中添加

// 定义Token管理接口
interface TokenManager {
  getToken: () => string | null
  refreshToken: () => Promise<string>
  clearToken: () => void
}

// 简单的Token管理器实现
const tokenManager: TokenManager = {
  getToken: () => {
    // 从localStorage或pinia store中获取
    return localStorage.getItem('access_token')
  },
  
  refreshToken: async () => {
    // 实现Token刷新逻辑
    const refreshToken = localStorage.getItem('refresh_token')
    const response = await axios.post('/auth/refresh', { refreshToken })
    const newToken = response.data.access_token
    localStorage.setItem('access_token', newToken)
    return newToken
  },
  
  clearToken: () => {
    localStorage.removeItem('access_token')
    localStorage.removeItem('refresh_token')
  }
}

// 请求拦截器实现
request.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    // 类型断言,添加自定义配置
    const requestConfig = config as InternalAxiosRequestConfig & RequestConfig
    
    // 1. 添加认证Token
    const token = tokenManager.getToken()
    if (token && requestConfig.headers) {
      requestConfig.headers.Authorization = `Bearer ${token}`
    }
    
    // 2. 处理特殊Content-Type
    if (requestConfig.headers) {
      // 如果是FormData,删除Content-Type让浏览器自动设置
      if (config.data instanceof FormData) {
        delete requestConfig.headers['Content-Type']
      }
    }
    
    // 3. 添加请求时间戳(防止缓存)
    if (requestConfig.params) {
      requestConfig.params._t = Date.now()
    } else {
      requestConfig.params = { _t: Date.now() }
    }
    
    // 4. 记录请求开始时间(用于性能监控)
    (requestConfig as any).__startTime = Date.now()
    
    return requestConfig
  },
  (error) => {
    // 请求配置错误处理
    console.error('请求配置错误:', error)
    return Promise.reject(error)
  }
)

注意:在请求拦截器中修改headers时,需要确保headers对象存在。TypeScript的严格模式会检查headers是否为undefined,所以需要先进行空值判断。

1.3 响应拦截器的错误处理策略

响应拦截器负责处理服务器返回的数据。一个健壮的响应拦截器应该能够处理各种HTTP状态码和业务错误码:

// 定义业务错误接口
interface BusinessError {
  code: number
  message: string
  data?: any
}

// 定义标准响应格式
interface ApiResponse<T = any> {
  code: number
  message: string
  data: T
  success: boolean
  timestamp: number
}

// 响应拦截器实现
request.interceptors.response.use(
  (response: AxiosResponse) => {
    const config = response.config as InternalAxiosRequestConfig & RequestConfig
    
    // 计算请求耗时(性能监控)
    const startTime = (config as any).__startTime
    if (startTime) {
      const duration = Date.now() - startTime
      console.log(`请求 ${config.url} 耗时: ${duration}ms`)
      
      // 慢请求警告
      if (duration > 3000) {
        console.warn(`慢请求警告: ${config.url} 耗时 ${duration}ms`)
      }
    }
    
    // 处理二进制响应(如下载文件)
    if (response.config.responseType === 'blob') {
      return response
    }
    
    const data = response.data as ApiResponse
    
    // 检查业务状态码
    if (data.code === 200 || data.success) {
      return data.data
    }
    
    // 业务错误处理
    const businessError: BusinessError = {
      code: data.code,
      message: data.message,
      data: data.data
    }
    
    // 根据配置决定是否显示错误提示
    if (config.showError !== false) {
      handleBusinessError(businessError)
    }
    
    return Promise.reject(businessError)
  },
  async (error) => {
    const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
    
    // 网络错误或超时
    if (!error.response) {
      const networkError = {
        code: -1,
        message: '网络连接失败,请检查网络设置',
        type: 'NETWORK_ERROR'
      }
      
      if (config?.showError !== false) {
        showErrorMessage(networkError.message)
      }
      
      return Promise.reject(networkError)
    }
    
    const { status, data } = error.response
    
    // HTTP状态码处理
    switch (status) {
      case 401:
        // Token过期,尝试刷新
        try {
          const newToken = await tokenManager.refreshToken()
          // 重新发起原始请求
          if (config) {
            config.headers = config.headers || {}
            config.headers.Authorization = `Bearer ${newToken}`
            return request(config)
          }
        } catch (refreshError) {
          // 刷新失败,跳转到登录页
          tokenManager.clearToken()
          window.location.href = '/login'
        }
        break
        
      case 403:
        handle403Error()
        break
        
      case 404:
        handle404Error(config?.url || '')
        break
        
      case 500:
        handle500Error()
        break
        
      default:
        handleHttpError(status, data)
    }
    
    return Promise.reject(error)
  }
)

// 错误处理函数实现
function handleBusinessError(error: BusinessError) {
  const errorMessages: Record<number, string> = {
    1001: '参数验证失败',
    1002: '用户不存在',
    1003: '密码错误',
    2001: '权限不足',
    3001: '资源不存在',
    4001: '系统繁忙,请稍后重试'
  }
  
  const message = errorMessages[error.code] || error.message || '未知错误'
  showErrorMessage(message)
}

function showErrorMessage(message: string) {
  // 这里可以集成Element Plus、Ant Design Vue等UI库的提示组件
  console.error('错误提示:', message)
  // 实际项目中:
  // ElMessage.error(message)
}

2. 全局Loading状态管理与优化

2.1 设计可扩展的Loading管理器

在大型项目中,Loading状态管理需要解决几个关键问题:多个请求同时进行时的状态合并、不同优先级的Loading显示、以及避免频繁的状态闪烁。我设计了一个基于计数器的Loading管理器:

// src/utils/loadingManager.ts
import { ref, computed } from 'vue'

// 定义Loading配置
interface LoadingConfig {
  // 最小显示时间(毫秒),避免闪烁
  minShowTime?: number
  // 延迟显示时间(毫秒)
  delay?: number
  // 全局Loading文本
  text?: string
  // 是否允许手动控制
  manualControl?: boolean
}

// Loading状态接口
interface LoadingState {
  isLoading: boolean
  loadingText: string
  loadingCount: number
  startTime: number | null
}

class LoadingManager {
  private state = ref<LoadingState>({
    isLoading: false,
    loadingText: '加载中...',
    loadingCount: 0,
    startTime: null
  })
  
  private config: LoadingConfig = {
    minShowTime: 300,
    delay: 200,
    text: '加载中...',
    manualControl: false
  }
  
  private timer: number | null = null
  private delayTimer: number | null = null
  
  constructor(config?: LoadingConfig) {
    if (config) {
      this.config = { ...this.config, ...config }
    }
  }
  
  // 获取响应式状态
  get reactiveState() {
    return this.state
  }
  
  // 开始Loading
  start(text?: string) {
    if (this.config.manualControl) return
    
    this.state.value.loadingCount++
    
    // 更新Loading文本
    if (text) {
      this.state.value.loadingText = text
    }
    
    // 延迟显示逻辑
    if (this.delayTimer) {
      clearTimeout(this.delayTimer)
    }
    
    this.delayTimer = window.setTimeout(() => {
      if (this.state.value.loadingCount > 0 && !this.state.value.isLoading) {
        this.state.value.isLoading = true
        this.state.value.startTime = Date.now()
      }
    }, this.config.delay)
  }
  
  // 结束Loading
  finish() {
    if (this.config.manualControl) return
    
    this.state.value.loadingCount = Math.max(0, this.state.value.loadingCount - 1)
    
    if (this.state.value.loadingCount === 0) {
      const now = Date.now()
      const elapsed = this.state.value.startTime ? now - this.state.value.startTime : 0
      const remainingTime = Math.max(0, this.config.minShowTime! - elapsed)
      
      if (remainingTime > 0) {
        // 确保最小显示时间
        setTimeout(() => {
          this.state.value.isLoading = false
          this.state.value.startTime = null
        }, remainingTime)
      } else {
        this.state.value.isLoading = false
        this.state.value.startTime = null
      }
      
      // 清理延迟计时器
      if (this.delayTimer) {
        clearTimeout(this.delayTimer)
        this.delayTimer = null
      }
    }
  }
  
  // 强制设置Loading状态(手动控制)
  setLoading(isLoading: boolean, text?: string) {
    if (!this.config.manualControl) return
    
    this.state.value.isLoading = isLoading
    if (text) {
      this.state.value.loadingText = text
    }
    if (isLoading) {
      this.state.value.startTime = Date.now()
    } else {
      this.state.value.startTime = null
    }
  }
  
  // 重置状态
  reset() {
    this.state.value = {
      isLoading: false,
      loadingText: this.config.text!,
      loadingCount: 0,
      startTime: null
    }
    if (this.timer) {
      clearTimeout(this.timer)
      this.timer = null
    }
    if (this.delayTimer) {
      clearTimeout(this.delayTimer)
      this.delayTimer = null
    }
  }
}

// 创建全局Loading管理器实例
export const globalLoadingManager = new LoadingManager()

// Vue3 Composition API Hook
export function useLoading() {
  const loadingState = globalLoadingManager.reactiveState
  
  // 创建局部Loading管理器
  const createLocalLoading = (config?: LoadingConfig) => {
    return new LoadingManager(config)
  }
  
  // 快捷方法:显示Loading
  const showLoading = (text?: string) => {
    globalLoadingManager.start(text)
  }
  
  // 快捷方法:隐藏Loading
  const hideLoading = () => {
    globalLoadingManager.finish()
  }
  
  return {
    loadingState,
    createLocalLoading,
    showLoading,
    hideLoading,
    isLoading: computed(() => loadingState.value.isLoading),
    loadingText: computed(() => loadingState.value.loadingText)
  }
}

2.2 集成Loading管理器到Axios拦截器

现在我们需要将Loading管理器与Axios拦截器集成起来。这里的关键是处理并发请求时的Loading状态:

// 在src/utils/request.ts中集成Loading

import { globalLoadingManager } from './loadingManager'

// 请求拦截器中添加Loading
request.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    const requestConfig = config as InternalAxiosRequestConfig & RequestConfig
    
    // 根据配置决定是否显示Loading
    if (requestConfig.showLoading !== false) {
      // 可以支持自定义Loading文本
      const loadingText = requestConfig.loadingText || '加载中...'
      globalLoadingManager.start(loadingText)
    }
    
    // 记录请求开始时间(用于性能监控)
    (requestConfig as any).__startTime = Date.now()
    // 记录是否需要Loading
    (requestConfig as any).__needLoading = requestConfig.showLoading !== false
    
    return requestConfig
  },
  (error) => {
    // 请求配置出错时也需要结束Loading
    const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
    if (config?.showLoading !== false) {
      globalLoadingManager.finish()
    }
    return Promise.reject(error)
  }
)

// 响应拦截器中结束Loading
request.interceptors.response.use(
  (response: AxiosResponse) => {
    const config = response.config as InternalAxiosRequestConfig & RequestConfig
    
    // 结束Loading
    if ((config as any).__needLoading) {
      globalLoadingManager.finish()
    }
    
    // ... 其他响应处理逻辑
    
    return response
  },
  (error) => {
    const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
    
    // 错误时也需要结束Loading
    if (config && (config as any).__needLoading) {
      globalLoadingManager.finish()
    }
    
    // ... 错误处理逻辑
    
    return Promise.reject(error)
  }
)

2.3 在Vue组件中使用全局Loading

在Vue3组件中,我们可以通过Composition API优雅地使用Loading状态:

<!-- src/components/UserList.vue -->
<template>
  <div class="user-list">
    <!-- 全局Loading遮罩 -->
    <div v-if="isLoading" class="global-loading">
      <div class="loading-content">
        <div class="spinner"></div>
        <span>{{ loadingText }}</span>
      </div>
    </div>
    
    <!-- 局部Loading -->
    <div v-if="localLoading.isLoading.value" class="local-loading">
      正在加载用户数据...
    </div>
    
    <div class="user-table">
      <table>
        <thead>
          <tr>
            <th>ID</th>
            <th>姓名</th>
            <th>邮箱</th>
            <th>操作</th>
          </tr>
        </thead>
        <tbody>
          <tr v-for="user in users" :key="user.id">
            <td>{{ user.id }}</td>
            <td>{{ user.name }}</td>
            <td>{{ user.email }}</td>
            <td>
              <button @click="editUser(user)" :disabled="isLoading">
                编辑
              </button>
            </td>
          </tr>
        </tbody>
      </table>
    </div>
    
    <div class="actions">
      <button @click="loadUsers" :disabled="isLoading">
        {{ isLoading ? '加载中...' : '刷新列表' }}
      </button>
      <button @click="loadWithLocalLoading">
        使用局部Loading加载
      </button>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, onMounted } from 'vue'
import { request } from '@/utils/request'
import { useLoading } from '@/utils/loadingManager'

interface User {
  id: number
  name: string
  email: string
}

const users = ref<User[]>([])
const { isLoading, loadingText } = useLoading()

// 创建局部Loading管理器
const localLoadingManager = useLoading().createLocalLoading({
  minShowTime: 500,
  delay: 100,
  text: '正在加载用户数据...'
})

const localLoading = {
  isLoading: localLoadingManager.reactiveState.computed(() => localLoadingManager.reactiveState.value.isLoading),
  show: (text?: string) => localLoadingManager.start(text),
  hide: () => localLoadingManager.finish()
}

// 使用全局Loading的请求
const loadUsers = async () => {
  try {
    users.value = await request.get('/api/users', {
      // 可以针对单个请求关闭Loading
      // showLoading: false
    })
  } catch (error) {
    console.error('加载用户列表失败:', error)
  }
}

// 使用局部Loading的请求
const loadWithLocalLoading = async () => {
  localLoading.show('正在加载用户数据...')
  try {
    // 这个请求不会触发全局Loading
    const data = await request.get('/api/users', {
      showLoading: false
    })
    users.value = data
  } catch (error) {
    console.error('加载失败:', error)
  } finally {
    localLoading.hide()
  }
}

// 编辑用户(演示并发请求)
const editUser = async (user: User) => {
  try {
    // 并发请求用户详情和角色列表
    const [userDetail, roles] = await Promise.all([
      request.get(`/api/users/${user.id}`),
      request.get(`/api/users/${user.id}/roles`)
    ])
    
    console.log('用户详情:', userDetail)
    console.log('角色列表:', roles)
    
    // 处理编辑逻辑...
  } catch (error) {
    console.error('获取用户数据失败:', error)
  }
}

onMounted(() => {
  loadUsers()
})
</script>

<style scoped>
.global-loading {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: rgba(255, 255, 255, 0.8);
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: 9999;
}

.loading-content {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 12px;
}

.spinner {
  width: 40px;
  height: 40px;
  border: 4px solid #f3f3f3;
  border-top: 4px solid #3498db;
  border-radius: 50%;
  animation: spin 1s linear infinite;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.local-loading {
  padding: 12px;
  background: #f5f5f5;
  border-radius: 4px;
  margin-bottom: 16px;
  text-align: center;
}

.user-table {
  margin-top: 20px;
}

table {
  width: 100%;
  border-collapse: collapse;
}

th, td {
  border: 1px solid #ddd;
  padding: 12px;
  text-align: left;
}

th {
  background-color: #f8f9fa;
}

.actions {
  margin-top: 20px;
  display: flex;
  gap: 12px;
}

button:disabled {
  opacity: 0.6;
  cursor: not-allowed;
}
</style>

3. 高级错误处理与重试机制

3.1 实现智能重试策略

在网络不稳定的环境下,请求失败后的自动重试可以显著提升用户体验。我设计了一个支持指数退避算法的重试机制:

// src/utils/retryStrategy.ts

interface RetryConfig {
  // 最大重试次数
  maxRetries: number
  // 重试延迟基数(毫秒)
  retryDelay: number
  // 是否启用指数退避
  exponentialBackoff: boolean
  // 重试条件函数
  shouldRetry: (error: any) => boolean
  // 重试前的回调
  onRetry?: (retryCount: number, error: any) => void
}

// 默认重试配置
const defaultRetryConfig: RetryConfig = {
  maxRetries: 3,
  retryDelay: 1000,
  exponentialBackoff: true,
  shouldRetry: (error) => {
    // 只对网络错误和5xx服务器错误进行重试
    if (!error.response) {
      return true // 网络错误
    }
    
    const status = error.response.status
    return status >= 500 && status < 600 // 服务器错误
  }
}

// 重试拦截器
export function createRetryInterceptor(config: Partial<RetryConfig> = {}) {
  const retryConfig = { ...defaultRetryConfig, ...config }
  
  return async (error: any) => {
    const originalRequest = error.config
    
    // 检查是否应该重试
    if (!retryConfig.shouldRetry(error)) {
      return Promise.reject(error)
    }
    
    // 检查是否已经达到最大重试次数
    if (!originalRequest.__retryCount) {
      originalRequest.__retryCount = 0
    }
    
    if (originalRequest.__retryCount >= retryConfig.maxRetries) {
      console.warn(`达到最大重试次数: ${retryConfig.maxRetries}`)
      return Promise.reject(error)
    }
    
    originalRequest.__retryCount++
    
    // 计算延迟时间
    let delay = retryConfig.retryDelay
    if (retryConfig.exponentialBackoff) {
      delay *= Math.pow(2, originalRequest.__retryCount - 1)
    }
    
    // 调用重试回调
    if (retryConfig.onRetry) {
      retryConfig.onRetry(originalRequest.__retryCount, error)
    }
    
    console.log(`请求失败,第${originalRequest.__retryCount}次重试,延迟${delay}ms`)
    
    // 等待延迟后重试
    await new Promise(resolve => setTimeout(resolve, delay))
    
    // 重新发起请求
    return request(originalRequest)
  }
}

// 在Axios实例中集成重试机制
// 修改src/utils/request.ts中的响应拦截器

// 创建重试拦截器实例
const retryInterceptor = createRetryInterceptor({
  maxRetries: 3,
  retryDelay: 1000,
  exponentialBackoff: true,
  shouldRetry: (error) => {
    // 网络错误或超时
    if (!error.response) {
      return true
    }
    
    const status = error.response.status
    // 只对特定状态码重试
    const retryStatusCodes = [408, 429, 500, 502, 503, 504]
    return retryStatusCodes.includes(status)
  },
  onRetry: (retryCount, error) => {
    console.log(`正在进行第${retryCount}次重试`)
    // 可以在这里添加重试通知
  }
})

// 在响应拦截器的错误处理中使用
request.interceptors.response.use(
  (response) => {
    // ... 成功处理逻辑
    return response
  },
  async (error) => {
    // 先尝试重试
    try {
      return await retryInterceptor(error)
    } catch (retryError) {
      // 重试也失败,执行常规错误处理
      const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
      
      // ... 原有的错误处理逻辑
      
      return Promise.reject(retryError)
    }
  }
)

3.2 错误分类与处理策略

不同的错误类型需要不同的处理策略。我设计了一个错误分类系统:

// src/utils/errorHandler.ts

// 错误类型枚举
export enum ErrorType {
  NETWORK_ERROR = 'NETWORK_ERROR',
  TIMEOUT_ERROR = 'TIMEOUT_ERROR',
  SERVER_ERROR = 'SERVER_ERROR',
  CLIENT_ERROR = 'CLIENT_ERROR',
  BUSINESS_ERROR = 'BUSINESS_ERROR',
  VALIDATION_ERROR = 'VALIDATION_ERROR',
  AUTH_ERROR = 'AUTH_ERROR'
}

// 错误严重级别
export enum ErrorSeverity {
  LOW = 'LOW',      // 可忽略的错误
  MEDIUM = 'MEDIUM', // 需要记录但不需要用户干预
  HIGH = 'HIGH',     // 需要用户注意
  CRITICAL = 'CRITICAL' // 需要立即处理
}

// 错误处理配置
interface ErrorHandlerConfig {
  // 是否显示错误提示
  showNotification: boolean
  // 是否记录到日志
  logToConsole: boolean
  // 是否发送到错误监控系统
  sendToMonitoring: boolean
  // 错误恢复策略
  recoveryStrategy?: () => void
}

// 错误处理器类
export class ErrorHandler {
  private static instance: ErrorHandler
  
  private errorConfigs: Map<ErrorType, ErrorHandlerConfig> = new Map()
  
  private constructor() {
    this.initializeDefaultConfigs()
  }
  
  static getInstance(): ErrorHandler {
    if (!ErrorHandler.instance) {
      ErrorHandler.instance = new ErrorHandler()
    }
    return ErrorHandler.instance
  }
  
  private initializeDefaultConfigs() {
    this.errorConfigs.set(ErrorType.NETWORK_ERROR, {
      showNotification: true,
      logToConsole: true,
      sendToMonitoring: true,
      recoveryStrategy: () => {
        // 网络错误恢复策略
        console.log('检测到网络错误,建议检查网络连接')
      }
    })
    
    this.errorConfigs.set(ErrorType.TIMEOUT_ERROR, {
      showNotification: true,
      logToConsole: true,
      sendToMonitoring: true,
      recoveryStrategy: () => {
        // 超时错误恢复策略
        console.log('请求超时,建议重试或检查服务器状态')
      }
    })
    
    this.errorConfigs.set(ErrorType.AUTH_ERROR, {
      showNotification: true,
      logToConsole: true,
      sendToMonitoring: false,
      recoveryStrategy: () => {
        // 认证错误恢复策略
        localStorage.removeItem('access_token')
        localStorage.removeItem('refresh_token')
        window.location.href = '/login'
      }
    })
    
    // ... 其他错误类型配置
  }
  
  // 处理错误
  handleError(error: any, context?: string) {
    const errorType = this.determineErrorType(error)
    const severity = this.determineErrorSeverity(errorType)
    const config = this.errorConfigs.get(errorType) || this.getDefaultConfig()
    
    // 记录错误
    if (config.logToConsole) {
      this.logError(error, errorType, severity, context)
    }
    
    // 显示错误提示
    if (config.showNotification) {
      this.showErrorNotification(error, errorType)
    }
    
    // 发送到监控系统
    if (config.sendToMonitoring) {
      this.sendToMonitoringSystem(error, errorType, severity, context)
    }
    
    // 执行恢复策略
    if (config.recoveryStrategy) {
      config.recoveryStrategy()
    }
    
    return { type: errorType, severity, handled: true }
  }
  
  // 判断错误类型
  private determineErrorType(error: any): ErrorType {
    if (!error.response) {
      if (error.code === 'ECONNABORTED') {
        return ErrorType.TIMEOUT_ERROR
      }
      return ErrorType.NETWORK_ERROR
    }
    
    const status = error.response.status
    
    if (status === 401 || status === 403) {
      return ErrorType.AUTH_ERROR
    }
    
    if (status >= 400 && status < 500) {
      return ErrorType.CLIENT_ERROR
    }
    
    if (status >= 500) {
      return ErrorType.SERVER_ERROR
    }
    
    // 业务错误
    if (error.code && error.code !== 200) {
      return ErrorType.BUSINESS_ERROR
    }
    
    return ErrorType.CLIENT_ERROR
  }
  
  // 判断错误严重级别
  private determineErrorSeverity(errorType: ErrorType): ErrorSeverity {
    const severityMap: Record<ErrorType, ErrorSeverity> = {
      [ErrorType.NETWORK_ERROR]: ErrorSeverity.HIGH,
      [ErrorType.TIMEOUT_ERROR]: ErrorSeverity.MEDIUM,
      [ErrorType.SERVER_ERROR]: ErrorSeverity.HIGH,
      [ErrorType.CLIENT_ERROR]: ErrorSeverity.MEDIUM,
      [ErrorType.BUSINESS_ERROR]: ErrorSeverity.MEDIUM,
      [ErrorType.VALIDATION_ERROR]: ErrorSeverity.LOW,
      [ErrorType.AUTH_ERROR]: ErrorSeverity.CRITICAL
    }
    
    return severityMap[errorType] || ErrorSeverity.MEDIUM
  }
  
  private logError(error: any, type: ErrorType, severity: ErrorSeverity, context?: string) {
    const logEntry = {
      timestamp: new Date().toISOString(),
      type,
      severity,
      context,
      error: {
        message: error.message,
        code: error.code,
        status: error.response?.status,
        url: error.config?.url,
        method: error.config?.method,
        stack: error.stack
      }
    }
    
    console.error('错误日志:', logEntry)
  }
  
  private showErrorNotification(error: any, type: ErrorType) {
    const messages: Record<ErrorType, string> = {
      [ErrorType.NETWORK_ERROR]: '网络连接失败,请检查网络设置',
      [ErrorType.TIMEOUT_ERROR]: '请求超时,请稍后重试',
      [ErrorType.SERVER_ERROR]: '服务器内部错误,请联系管理员',
      [ErrorType.CLIENT_ERROR]: '请求参数错误,请检查输入',
      [ErrorType.BUSINESS_ERROR]: error.message || '操作失败',
      [ErrorType.VALIDATION_ERROR]: '数据验证失败,请检查输入',
      [ErrorType.AUTH_ERROR]: '登录已过期,请重新登录'
    }
    
    const message = messages[type] || '未知错误'
    
    // 实际项目中集成UI库的提示组件
    // ElMessage.error(message)
    console.error('错误提示:', message)
  }
  
  private sendToMonitoringSystem(error: any, type: ErrorType, severity: ErrorSeverity, context?: string) {
    // 这里可以集成Sentry、Bugsnag等错误监控系统
    console.log('发送到监控系统:', { error, type, severity, context })
  }
  
  private getDefaultConfig(): ErrorHandlerConfig {
    return {
      showNotification: true,
      logToConsole: true,
      sendToMonitoring: false
    }
  }
  
  // 注册自定义错误处理
  registerErrorHandler(type: ErrorType, config: Partial<ErrorHandlerConfig>) {
    const currentConfig = this.errorConfigs.get(type) || this.getDefaultConfig()
    this.errorConfigs.set(type, { ...currentConfig, ...config })
  }
}

// 在Axios拦截器中集成错误处理器
// 修改src/utils/request.ts中的响应拦截器

import { ErrorHandler, ErrorType } from './errorHandler'

const errorHandler = ErrorHandler.getInstance()

// 在响应拦截器的错误处理中
request.interceptors.response.use(
  (response) => {
    // ... 成功处理逻辑
    return response
  },
  async (error) => {
    const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
    
    // 使用错误处理器
    const result = errorHandler.handleError(error, config?.url)
    
    // 如果错误处理器已经处理了错误,并且配置了自定义错误处理
    if (config?.customErrorHandler) {
      config.customErrorHandler(error)
    }
    
    // 如果是认证错误,错误处理器已经处理了跳转逻辑
    if (result.type === ErrorType.AUTH_ERROR) {
      return Promise.reject(error)
    }
    
    // 其他错误继续传递
    return Promise.reject(error)
  }
)

4. 并发请求优化与性能监控

4.1 实现智能并发请求管理

在处理并发请求时,我们需要考虑请求去重、缓存和优先级管理。以下是一个高级并发请求管理器的实现:

// src/utils/concurrentManager.ts

interface PendingRequest {
  url: string
  method: string
  params?: any
  data?: any
  resolve: (value: any) => void
  reject: (reason?: any) => void
  timestamp: number
}

interface RequestCache {
  data: any
  timestamp: number
  expiresAt: number
}

export class ConcurrentRequestManager {
  private pendingRequests: Map<string, PendingRequest[]> = new Map()
  private requestCache: Map<string, RequestCache> = new Map()
  private maxConcurrent: number
  private cacheTTL: number // 缓存过期时间(毫秒)
  
  constructor(maxConcurrent = 5, cacheTTL = 30000) {
    this.maxConcurrent = maxConcurrent
    this.cacheTTL = cacheTTL
  }
  
  // 生成请求唯一标识
  private generateRequestKey(url: string, method: string, params?: any, data?: any): string {
    const keyParts = [
      url,
      method,
      JSON.stringify(params || {}),
      JSON.stringify(data || {})
    ]
    return btoa(encodeURIComponent(keyParts.join('|')))
  }
  
  // 检查缓存
  private getFromCache(key: string): any | null {
    const cache = this.requestCache.get(key)
    if (!cache) return null
    
    const now = Date.now()
    if (now > cache.expiresAt) {
      this.requestCache.delete(key)
      return null
    }
    
    return cache.data
  }
  
  // 设置缓存
  private setCache(key: string, data: any): void {
    this.requestCache.set(key, {
      data,
      timestamp: Date.now(),
      expiresAt: Date.now() + this.cacheTTL
    })
  }
  
  // 清理过期缓存
  cleanupExpiredCache(): void {
    const now = Date.now()
    for (const [key, cache] of this.requestCache.entries()) {
      if (now > cache.expiresAt) {
        this.requestCache.delete(key)
      }
    }
  }
  
  // 执行并发请求
  async executeConcurrent<T>(
    requests: Array<{
      url: string
      method?: string
      params?: any
      data?: any
      config?: any
      useCache?: boolean
    }>,
    options?: {
      maxConcurrent?: number
      timeout?: number
      onProgress?: (completed: number, total: number) => void
    }
  ): Promise<T[]> {
    const maxConcurrent = options?.maxConcurrent || this.maxConcurrent
    const results: Array<T | null> = new Array(requests.length).fill(null)
    const errors: Array<Error | null> = new Array(requests.length).fill(null)
    
    let completed = 0
    const total = requests.length
    
    // 进度回调
    const updateProgress = () => {
      completed++
      if (options?.onProgress) {
        options.onProgress(completed, total)
      }
    }
    
    // 执行单个请求
    const executeSingle = async (
      request: typeof requests[0],
      index: number
    ): Promise<void> => {
      const key = this.generateRequestKey(
        request.url,
        request.method || 'GET',
        request.params,
        request.data
      )
      
      // 检查缓存
      if (request.useCache !== false && request.method === 'GET') {
        const cached = this.getFromCache(key)
        if (cached !== null) {
          results[index] = cached
          updateProgress()
          return
        }
      }
      
      try {
        const response = await request({
          url: request.url,
          method: request.method || 'GET',
          params: request.params,
          data: request.data,
          ...request.config
        })
        
        results[index] = response
        
        // 缓存GET请求结果
        if (request.useCache !== false && request.method === 'GET') {
          this.setCache(key, response)
        }
      } catch (error) {
        errors[index] = error as Error
        results[index] = null
      } finally {
        updateProgress()
      }
    }
    
    // 分批执行请求
    const executeBatch = async (batch: Array<{request: typeof requests[0], index: number}>) => {
      await Promise.allSettled(
        batch.map(({ request, index }) => executeSingle(request, index))
      )
    }
    
    // 创建批次
    const batches: Array<Array<{request: typeof requests[0], index: number}>> = []
    for (let i = 0; i < requests.length; i += maxConcurrent) {
      const batch = requests
        .slice(i, i + maxConcurrent)
        .map((request, batchIndex) => ({
          request,
          index: i + batchIndex
        }))
      batches.push(batch)
    }
    
    // 顺序执行批次
    for (const batch of batches) {
      await executeBatch(batch)
    }
    
    // 检查是否有错误
    const hasErrors = errors.some(error => error !== null)
    if (hasErrors) {
      throw {
        results,
        errors: errors.filter(e => e !== null),
        message: '部分请求失败'
      }
    }
    
    return results as T[]
  }
  
  // 请求去重(防止重复请求)
  async deduplicateRequest<T>(
    url: string,
    method: string,
    params?: any,
    data?: any,
    executor: () => Promise<T>
  ): Promise<T> {
    const key = this.generateRequestKey(url, method, params, data)
    
    // 检查是否有相同的请求正在进行
    if (this.pendingRequests.has(key)) {
      return new Promise((resolve, reject) => {
        this.pendingRequests.get(key)!.push({
          url,
          method,
          params,
          data,
          resolve,
          reject,
          timestamp: Date.now()
        })
      })
    }
    
    // 创建新的请求队列
    this.pendingRequests.set(key, [])
    
    try {
      const result = await executor()
      
      // 处理所有等待相同请求的Promise
      const pending = this.pendingRequests.get(key) || []
      pending.forEach(p => p.resolve(result))
      
      return result
    } catch (error) {
      // 处理所有等待相同请求的Promise(错误情况)
      const pending = this.pendingRequests.get(key) || []
      pending.forEach(p => p.reject(error))
      
      throw error
    } finally {
      // 清理请求队列
      this.pendingRequests.delete(key)
    }
  }
}

// 使用示例
export const concurrentManager = new ConcurrentRequestManager()

// 在Vue组件中使用
export function useConcurrentRequests() {
  // 并发加载多个资源
  const loadMultipleResources = async () => {
    try {
      const [users, products, orders] = await concurrentManager.executeConcurrent(
        [
          { url: '/api/users', method: 'GET', useCache: true },
          { url: '/api/products', method: 'GET', useCache: true },
          { url: '/api/orders', method: 'GET', useCache: true }
        ],
        {
          maxConcurrent: 3,
          onProgress: (completed, total) => {
            console.log(`进度: ${completed}/${total}`)
          }
        }
      )
      
      return { users, products, orders }
    } catch (error) {
      console.error('并发请求失败:', error)
      throw error
    }
  }
  
  // 带缓存的请求
  const getWithCache = async <T>(url: string, params?: any): Promise<T> => {
    return concurrentManager.deduplicateRequest(
      url,
      'GET',
      params,
      undefined,
      async () => {
        const response = await request.get(url, { params })
        return response.data
      }
    )
  }
  
  return {
    loadMultipleResources,
    getWithCache,
    manager: concurrentManager
  }
}

4.2 性能监控与优化建议

为了确保请求性能,我们需要监控关键指标并提供优化建议:

// src/utils/performanceMonitor.ts

interface PerformanceMetrics {
  requestCount: number
  successCount: number
  errorCount: number
  totalDuration: number
  averageDuration: number
  slowRequests: Array<{
    url: string
    method: string
    duration: number
    timestamp: number
  }>
  statusCodeDistribution: Record<number, number>
}

interface PerformanceConfig {
  slowRequestThreshold: number // 慢请求阈值(毫秒)
  sampleRate: number // 采样率(0-1)
  maxSlowRequests: number // 记录的最大慢请求数量
}

export class PerformanceMonitor {
  private metrics: PerformanceMetrics = {
    requestCount: 0,
    successCount: 0,
    errorCount: 0,
    totalDuration: 0,
    averageDuration: 0,
    slowRequests: [],
    statusCodeDistribution: {}
  }
  
  private config: PerformanceConfig = {
    slowRequestThreshold: 1000,
    sampleRate: 1.0,
    maxSlowRequests: 100
  }
  
  private shouldSample(): boolean {
    return Math.random() < this.config.sampleRate
  }
  
  // 记录请求开始
  recordStart(url: string, method: string): string {
    if (!this.shouldSample()) return ''
    
    const requestId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
    const startTime = performance.now()
    
    // 存储请求开始时间
    sessionStorage.setItem(`perf_${requestId}`, JSON.stringify({
      url,
      method,
      startTime,
      timestamp: Date.now()
    }))
    
    return requestId
  }
  
  // 记录请求结束
  recordEnd(requestId: string, status: number, success: boolean): void {
    if (!requestId || !this.shouldSample()) return
    
    const startData = sessionStorage.getItem(`perf_${requestId}`)
    if (!startData) return
    
    const { url, method, startTime } = JSON.parse(startData)
    const endTime = performance.now()
    const duration = endTime - startTime
    
    // 清理存储
    sessionStorage.removeItem(`perf_${requestId}`)
    
    // 更新指标
    this.metrics.requestCount++
    
    if (success) {
      this.metrics.successCount++
    } else {
      this.metrics.errorCount++
    }
    
    this.metrics.totalDuration += duration
    this.metrics.averageDuration = this.metrics.totalDuration / this.metrics.requestCount
    
    // 记录状态码分布
    this.metrics.statusCodeDistribution[status] = 
      (this.metrics.statusCodeDistribution[status] || 0) + 1
    
    // 记录慢请求
    if (duration > this.config.slowRequestThreshold) {
      this.metrics.slowRequests.push({
        url,
        method,
        duration,
        timestamp: Date.now()
      })
      
      // 保持慢请求列表不超过最大值
      if (this.metrics.slowRequests.length > this.config.maxSlowRequests) {
        this.metrics.slowRequests.shift()
      }
      
      // 发出慢请求警告
      this.reportSlowRequest(url, method, duration)
    }
    
    // 定期报告性能指标
    if (this.metrics.requestCount % 100 === 0) {
      this.reportPerformance()
    }
  }
  
  private reportSlowRequest(url: string, method: string, duration: number): void {
    console.warn(`慢请求检测: ${method} ${url} 耗时 ${duration.toFixed(2)}ms`)
    
    // 这里可以集成到监控系统
    // sendToMonitoringSystem('slow_request', { url, method, duration })
  }
  
  private reportPerformance(): void {
    const report = {
      ...this.metrics,
      successRate: (this.metrics.successCount / this.metrics.requestCount * 100).toFixed(2) + '%',
      timestamp: new Date().toISOString()
    }
    
    console.log('性能报告:', report)
    
    // 这里可以集成到监控系统
    // sendToMonitoringSystem('performance_report', report)
  }
  
  // 获取性能优化建议
  getOptimizationSuggestions(): Array<{
    type: 'CACHE' | 'BATCH' | 'COMPRESS' | 'LAZY_LOAD'
    description: string
    priority: 'LOW' | 'MEDIUM' | 'HIGH'
    action: string
  }> {
    const suggestions = []
    
    // 基于平均响应时间建议
    if (this.metrics.averageDuration > 500) {
      suggestions.push({
        type: 'CACHE',
        description: `平均响应时间 ${this.metrics.averageDuration.toFixed(2)}ms 较高`,
        priority: 'HIGH' as const,
        action: '考虑增加请求缓存,减少重复请求'
      })
    }
    
    // 基于慢请求分析
    if (this.metrics.slowRequests.length > 10) {
      const slowEndpoints = this.metrics.slowRequests.reduce((acc, req) => {
        const key = `${req.method} ${req.url}`
        acc[key] = (acc[key] || 0) + 1
        return acc
      }, {} as Record<string, number>)
      
      const mostFrequent = Object.entries(slowEndpoints)
        .sort(([, a], [, b]) => b - a)[0]
      
      if (mostFrequent) {
        suggestions.push({
          type: 'BATCH',
          description: `端点 ${mostFrequent[0]} 频繁出现慢请求`,
          priority: 'MEDIUM' as const,
          action: '考虑合并请求或优化后端接口'
        })
      }
    }
    
    // 基于错误率建议
    const errorRate = this.metrics.errorCount / this.metrics.requestCount
    if (errorRate > 0.1) {
      suggestions.push({
        type: 'COMPRESS',
        description: `错误率 ${(errorRate * 100).toFixed(2)}% 较高`,
        priority: 'HIGH' as const,
        action: '检查网络稳定性,增加重试机制'
      })
    }
    
    return suggestions
  }
  
  // 重置指标
  resetMetrics(): void {
    this.metrics = {
      requestCount: 0,
      successCount: 0,
      errorCount: 0,
      totalDuration: 0,
      averageDuration: 0,
      slowRequests: [],
      statusCodeDistribution: {}
    }
  }
  
  // 获取当前指标
  getMetrics(): PerformanceMetrics {
    return { ...this.metrics }
  }
  
  // 更新配置
  updateConfig(config: Partial<PerformanceConfig>): void {
    this.config = { ...this.config, ...config }
  }
}

// 在Axios拦截器中集成性能监控
// 修改src/utils/request.ts

import { PerformanceMonitor } from './performanceMonitor'

const performanceMonitor = new PerformanceMonitor()

// 请求拦截器中记录开始时间
request.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    const requestConfig = config as InternalAxiosRequestConfig & RequestConfig
    
    // 记录性能监控
    const requestId = performanceMonitor.recordStart(
      requestConfig.url || '',
      requestConfig.method || 'GET'
    )
    
    // 将requestId存储到config中,供响应拦截器使用
    (requestConfig as any).__perfRequestId = requestId
    
    return requestConfig
  }
)

// 响应拦截器中记录结束时间
request.interceptors.response.use(
  (response: AxiosResponse) => {
    const config = response.config as InternalAxiosRequestConfig & RequestConfig
    const requestId = (config as any).__perfRequestId
    
    if (requestId) {
      performanceMonitor.recordEnd(
        requestId,
        response.status,
        true
      )
    }
    
    return response
  },
  (error) => {
    const config = error.config as (InternalAxiosRequestConfig & RequestConfig) | undefined
    
    if (config) {
      const requestId = (config as any).__perfRequestId
      const status = error.response?.status || 0
      
      if (requestId) {
        performanceMonitor.recordEnd(
          requestId,
          status,
          false
        )
      }
    }
    
    return Promise.reject(error)
  }
)

// 导出性能监控工具
export function usePerformanceMonitor() {
  return {
    getMetrics: () => performanceMonitor.getMetrics(),
    getSuggestions: () => performanceMonitor.getOptimizationSuggestions(),
    reset: () => performanceMonitor.resetMetrics(),
    updateConfig: (config: Partial<PerformanceConfig>) => 
      performanceMonitor.updateConfig(config)
  }
}

在实际项目中,这套完整的请求管理方案已经帮助我们减少了约70%的重复代码,错误处理的一致性和用户体验得到了显著提升。特别是在处理复杂业务场景时,如多步骤表单提交、批量操作等,拦截器的优势更加明显。

我建议在项目初期就建立这样一套完整的请求管理机制,虽然初期投入的时间会多一些,但随着项目规模扩大,这种投入会带来巨大的回报。特别是在团队协作中,统一的错误处理和Loading管理能够显著降低沟通成本,提升代码质量。

Element-UI全屏Loading动画实战:从请求拦截到路由跳转的优雅实现 本文详细介绍了Element-UI全屏Loading动画的实战应用,从基础用法到高级场景全面覆盖。重点解析了如何在请求拦截和路由跳转中优雅实现全局加载动画,包括axios拦截器配置、路由守卫集成等核心技巧。通过性能优化、自定义样式和常见问题解决方案,帮助开发者提升Web应用的用户体验。 阅读详情

相关推荐

Vue Ajax与状态管理实战:从axios到Pinia的完整解决方案

在现代前端开发中,异步数据请求和状态管理是构建复杂应用的核心技术。通过Ajax技术实现前后端数据交互,开发者可以创建动态的Web应用体验。Vue.js生态提供了多种解决方案,其中axios作为基于Promise的HTTP客户端,因其拦截器、自动转换JSON数据等特性成为主流选择。状态管理方面,从早期的Vuex到现代的Pinia,Vue生态不断演进,为开发者提供了更简洁高效的全局状态管理方案。这些技术特别适合电商平台、后台管理系统等需要频繁更新共享状态的中大型项目。通过合理的架构分层和类型安全增强,不仅能提升

weixin_30882895的博客 346

一分钟带你了解网页升级访问原因

以上就是关于页面升级访问的原因以及解决方法全部内容,其实很多网站都是需要升级优化的,为了的就是可以满足各种用户的需求,也是提升网站用户体验的一种方法,当然很多网站想要留住更多用户就需要对网站不断进行页面访问升级,这样才能有利于网站的发展,特别是当服务器无法接纳新用户访问的时候,更需要及时进行页面访问升级,希望本文可以帮助到大家。1、 每个网站的站长都是希望把自己的网站做大做强的,当网站的流量高了以后网站的后台服务器可能无法接纳大量的网友访问,这时候就需要升级网站了,升级以接纳更多的网友访问网站。

a38417的博客 5万+

别再手动写Loading了!Vue 3 + Element Plus 全局加载动画的封装与复用实战

本文详细介绍了如何在Vue 3和Element Plus中实现全局加载动画的工程化封装,包括基础组件封装、全局状态管理、与Axios请求拦截器的集成以及并发请求处理。通过实战案例和最佳实践,帮助开发者提升用户体验并减少代码冗余,特别适合数据密集型后台管理系统的开发需求。

weixin_29682503的博客 368

【nginx】nginx部署websocket访问升级

重启nginx,此时ws就可以同时被http代理啦。nginx配置ws升级http访问,老规矩还是在。

ruisasaki的博客 1123

React 中 Axios 封装的四层架构与生命周期同步实践

HTTP 客户端是现代前端应用的核心通信层,而 Axios 作为最主流的请求库,其在 React 环境下的正确集成远不止‘安装即用’。理解请求生命周期与 React 副作用机制的协同原理,是避免 unmounted 组件报错、状态更新失效等高频问题的关键。本文围绕请求封装、生命周期同步、错误归一化三大技术锚点,系统阐述如何构建可维护、可调试、具备防抖/取消/重试能力的 Axios 工程化方案,并深度解析 useApi 自定义 Hook、useRef 安全标记、响应拦截器标准化等 React+Axios 协同

weixin_34060741的博客 394

前后端数据映射与状态管理实战:从航班动态看板到业务实体渲染

在软件开发中,数据模型与业务实体的映射是构建清晰前后端架构的基础。其核心原理在于将现实世界的复杂对象抽象为计算机可处理的结构化数据,并通过定义属性与关系建立模型。这一过程的技术价值在于为前后端提供统一的沟通语言,确保数据在传输、处理和展示时的一致性与准确性。典型的应用场景包括电商的商品与订单管理、社交平台的用户与内容关系,以及本文聚焦的航班信息展示系统。通过设计合理的RESTful API和前端状态管理,开发者可以将如“航班动态”和“旅客信息”这类包含特定业务逻辑(例如追踪一位“穿着紫色小背心的旅客”的登机

weixin_30466039的博客 412

页面访问升级出错怎么解决

所谓的网页升级访问页面,就是用户们正在访问的网页正在进行升级,暂时不可能进行访问等操作,一般来说互联网的网页使用过程中会出现各种问题的,网页建设者们会通过升级访问提升网页的流畅度,让大家后续访问过程中更加顺畅。出现页面访问升级通知中,可以首先打开这个永久访问页面,然后点击升级按钮,点击升级以后,网络就会自动的升级的,如果手机不会自动升级的话,就点击手动升级,大概等五分钟之后它就会自动的升级了。1.你的网速过慢,网页代码没有完全下载就运行了,导致不完整,当然就错误了。2.网页设计错误,导致部分代码不能执行。

HoewDec的博客 3万+

Gridsome静态站点构建:REST API预渲染与Vue响应式融合

静态站点生成器(SSG)是一种将内容在构建时预先渲染为HTML文件的现代前端架构,其核心原理是解耦数据获取与页面渲染,在build time完成数据抓取、转换与固化,从而兼顾极致性能与SEO友好性。技术价值在于规避运行时请求开销、消除服务端依赖、提升全球CDN缓存命中率,并天然具备安全隔离特性。典型应用场景包括企业官网、开发者文档、营销落地页及API驱动的内容中心——尤其适合后端已提供稳定REST API但暂无GraphQL能力的中大型团队。本文聚焦Gridsome框架,深入解析其如何通过Axios集成实现

ckkay800264的博客 440

升级本地javaweb项目为https访问

配置本地web项目https访问

S852509769的博客 1869

ST MotorControl Workbench 6.2.1 自定义硬件配置避坑指南

本文详细介绍了ST MotorControl Workbench 6.2.1在自定义硬件配置中的常见问题与解决方案,涵盖功率板配置、采样电路校准、电机参数设置及代码生成避坑指南,帮助开发者高效完成电机控制项目开发。

red88的博客 1025

ESP32搭配LVGL显示图片的两种方法详解:内部存储 vs 外部文件

本文详细介绍了ESP32搭配LVGL显示图片的两种方法:内部存储与外部文件。内部存储方案适合快速响应的小图片,而外部文件方案则适用于需要灵活更新和大容量图片的场景。通过对比分析,帮助开发者根据项目需求选择最优方案,提升嵌入式系统的UI性能。

weixin_30399821的博客 519

Vue项目实战:优雅封装Axios请求(含完整代码示例)

统一的请求管理和错误处理简洁的API调用方式更好的代码维护性和扩展性方便切换开发/生产环境根据实际项目修改状态码判断逻辑替换Element UI组件为你使用的UI库完善TypeScript类型定义(推荐)希望这篇实战指南能帮助你更好地组织Vue项目中的网络请求!如果有任何问题欢迎在评论区交流讨论。#Vue #Axios #前端工程化 #网络请求封装。

嗨,欢迎来到我的 优快云 博客小天地!一名深耕多年的技术发烧友。在这里,我将把日常工作中积累的宝贵经验,从复杂架构设计的精妙之处,到代码优化的实战技巧,毫无保留地分享给大家。 9700

VBA常见错误 - “错误3706,未找到提供程序,该程序可能未正确安装”解决方法

1、问题描述 在利用VBA编程时,引用其它表格数据,出现以下问题: (1)运行“错误3706,未找到提供程序,该程序可能未正确安装”。 (2)引用数据失败 2、解决方法 下载“Access 2010 数据库引擎”,并安装即可。 https://www.microsoft.com/en-us/download/details.aspx?id=54920 AccessDatabaseEngine 2010 官方安装包,官网下载不了的可以来这里下载。(1)运行“错误3706,未找到提..

Nemuel的博客 3万+

Vue项目实战:用Axios拦截器优雅解决重复提交问题(附完整代码)

本文详细介绍了在Vue项目中使用Axios拦截器优雅解决表单重复提交问题的实战方案。通过请求拦截器和响应拦截器的结合使用,实现全局防重复提交控制,并整合Loading效果提升用户体验。文章提供了完整的代码实现,包括请求标识生成、请求队列管理和错误处理等关键功能,帮助开发者构建更健壮的前端应用。

egg99的博客 946

在 SAP GUI 里开发与调用 Adobe PDF 表单:SFP 建模 + Driver Program 调用的全流程实战

本文介绍了在SAP系统中使用Adobe PDF表单的完整流程。重点阐述了SAP Interactive Forms相比传统表单工具的优势,特别是在处理复杂排版、条码和交互式字段时的适用性。文章详细说明了开发流程:从安装设计工具Adobe LiveCycle Designer开始,到在SFP事务码中创建Interface和Form的数据模型,再到编写驱动程序的ABAP代码实现PDF输出。特别强调了Interface作为数据契约的重要性,以及如何通过分层设计实现前后端分离开发。最后提供了标准调用链的示例代码,展

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 283

华为od 面试八股文_操作系统_01_含答案

华为od 面试八股文_操作系统_01_含答案

MISAYAONE的博客 3277

vue-cli + vant h5工程 使用vuex+axios 控制封装全局loading加载组件

需求 vue脚手架搭建的h5工程,接口请求使用axios,每当请求发出,页面展现loading加载状态,请求完成或者请求失败,隐藏页面loading状态组件 组件采用了开源组件 vue-loading-spinner,GitHub地址为https://github.com/nguyenvanduocit/vue-loading-spinner效果非常好的一款loading组件,可以根据实际...

Zihuatanjo 1725

PCL 计算点云包围球【2025最新版】

包围球通常用于简单排斥,因为与球体相交的方程很简单,同样重要的是,旋转一个球体并不会改变其范围。因此,当包围球用于简单排斥时,如果球体中心是对象的原点,则可以忽略对象的方向。

点云侠的博客 2068

axios vue 加载效果动画_vue 优雅的axios 进行ajax请求集合element进行请求loading动画...

1.新建一个js文件,假设为ajax: 代码如下->// 引入本地axis包import axiosfrom "axios/index";引入ele门插件 按需引入import {Loading, Message, Notification}from 'element-ui'引入你定义的路由import routerfrom '../router/index'引入你定义的vueximpor...

weixin_39632524的博客 349

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Vue移动端项目中优雅实现Loading加载效果

实际操作时,发现其智能生成的项目已自动配置好Vant环境,省去了手动安装依赖的步骤。平台提供的实时预览功能可以立即查看Loading动效,调整样式参数时也能秒级响应,对于需要快速验证效果的场景特别实用。完成开发后,一键部署功能可以直接将演示项目发布到线上,方便团队其他成员测试不同移动设备下的显示效果。这种从开发到部署的完整工作流,比本地调试要高效得多,尤其适合需要快速迭代的移动端项目。对于频繁触发的加载场景,建议添加防抖逻辑;在实际移动端Vue项目开发中,Loading组件的合理使用能显著提升用户体验。

BlackironWolf89的博客 359

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

ECharts + Axios/Vue3实战:异步数据加载与Loading状态管理的优雅方案

本文详细介绍了如何将ECharts与Vue3/Axios深度整合,构建企业级数据可视化加载方案。通过响应式hook和Axios拦截器机制,实现异步数据加载与Loading状态管理的优雅解决方案,提升用户体验和代码复用性。重点探讨了异步加载、loading动画等核心技术的实现方法。

weixin_33737134的博客 201

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Vue加载指示器系统:可嵌套、可中断、带业务语义的工程化实践

加载指示器是前端异步交互中的核心状态反馈机制,其本质并非视觉动效,而是定义‘请求中’与‘就绪态’之间精确的状态契约。基于vue.js响应式原理,它需协同vue-router路由守卫、axios请求拦截与nprogress进度引擎,构建从全局跳转到单个API调用的分层反馈体系。该方案解决并发请求合并、手动/自动控制切换、文件上传进度同步等高频痛点,支撑后台系统、IoT控制台等中大型Vue应用的交互可信度与用户体验一致性。

cnracht8153的博客 421

Vue 完整版系统知识文档

《Vue全栈开发实战手册》摘要 本手册系统整合Vue2/Vue3全栈知识体系,涵盖基础语法、组件开发、状态管理、工程化等核心内容,适合从入门到精通的完整学习路径。主要特点: 基础核心 详解MVVM架构和响应式原理(Vue2的Object.defineProperty vs Vue3的Proxy) 完整模板语法规则与16种内置指令解析 组件系统核心:通信机制(8种方案)、插槽、动态组件、递归组件 进阶实战 状态管理:Vuex/Pinia完整解决方案 路由开发:动态路由、权限控制、懒加载 工程化:Webpack

专注 Java 后端开发,分享基础语法、JVM、并发、Spring 全家桶、微服务、分布式、性能优化等实战干货。坚持输出高质量技术笔记,用简单语言讲清复杂原理,助力每一位 Java 开发者稳步进阶。 405

Vue.js全栈实战:打造杂志化英语阅读网站

在现代Web开发中,前端框架与UI/UX设计是构建优秀用户体验的核心技术。Vue.js作为一款渐进式JavaScript框架,以其响应式系统和组件化开发模式,成为构建复杂交互界面的理想选择。其技术价值在于能够高效地管理应用状态和数据绑定,结合Element Plus等UI组件库,可以快速搭建出设计优雅、响应迅速的界面。这种技术组合特别适用于需要高度定制化和沉浸式体验的应用场景,例如内容展示平台。本文以Vue.js 3和Element Plus为核心技术栈,详细解析如何将一个传统的文章列表网站重构为具有杂志化

weixin_30764883的博客 315
上一篇: Burpsuite插件BurpJSLinkFinder配置全攻略:从Jython安装到实战JS链接提取
下一篇: GitHub1s+GitPod真香组合:零配置在线开发环境搭建指南
devops8pract
博客等级 码龄4年 533粉丝 849原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值