Axios二次封装实战:鉴权、重复拦截、Loading、缓存与统一错误处理

axios二次封装axios拦截器请求重复拦截
于 2026-10-29 03:17:15 修改
·本内容遵循CC 4.0 BY-SA版权协议

去年年中我重构一个后台管理系统时,顺手做了一套 Axios 二次封装。当时项目里十几个页面裸调 axios,每个页面自己拼 token、自己 try/catch,遇到 401 就跳登录页,接口报错提示风格五花八门。那段时间线上天天有人反馈“点了按钮没反应”,排查下来全是重复提交、缓存失效、loading 状态捣乱。后来我把鉴权、重复拦截、Loading、缓存、统一错误、请求重试这六件事全部收拢到同一层,代码反而少了三分之一,排查问题也快了很多。这篇就把完整的封装方案拆开写清楚,代码带逐行注释,你在自己项目里可以直接抄。

这套方案适合什么场景?中等规模以上的中后台项目、管理后台、H5 应用,凡是存在多页面重复请求、token 过期需要统一处理的,都适用。如果你的项目只有三五个接口、没有登录态,那后面的鉴权和重试部分可以跳过,但重复拦截和缓存的设计思路仍然值得参考。

1. 从裸奔到统一出口:为什么要做这套封装

1.1 散装 axios 带来的四个问题

散装请求通常长这样:每个页面自己 axios.get(...),请求头里自己塞 token,loading 自己搞个变量控制,报错自己 alert。表面看没什么不妥,但项目一大人就麻了。我总结下来至少四个痛点。

第一个是鉴权逻辑散落。token 过期后每个页面跳登录页的方式都不一样,有的 window.location.href,有的 router.push,还有的直接白屏。第二个是重复请求没人管。用户双击搜索按钮、快速切换 Tab、Table 组件内部多次触发查询,同一个接口能发出去三四次,数据库压力倒是小事,界面数据经常被后返回的旧数据覆盖,体验很糟糕。第三个是 loading 状态很难维护。并发三个请求,每个请求都在 finally 里把 loading 置 false,结果前两个先返回,第三个还在跑,loading 就提前消失了。第四个是错误处理不统一。后端返回 { code: 50010, message: '余额不足' },有的页面只 console.log,有的页面直接弹窗,有的直接把后端 message 扔给用户看,后端文案写得再烂也没人拦着。

这些问题的根子不是 axios 不好用,而是缺少一个统一的出口。所谓出口,就是所有请求必须经过同一个方法发出去,所有拦截逻辑都挂在这条链路里。这样改动鉴权规则、调整错误提示、加缓存策略,都只动一处。

1.2 封装边界:拦截器、实例、方法层各自做什么

很多同学一上来就把所有逻辑塞进拦截器,结果拦截器写得跟裹脚布一样。我建议分成三层思考。

第一层是 axios 实例层,负责最基础的配置:baseURL、超时时间、请求头默认值。这一层不需要太多业务逻辑。第二层是拦截器层,负责所有请求“经过这里一次”的切面逻辑:注入 token、生成请求指纹、登记 pending、打开 loading;响应回来时移除 pending、关闭 loading、处理 HTTP 错误和业务错误码。第三层是方法层,也就是我们自己暴露出去的 request 函数。这一层做两件拦截器不太好做的事:一是缓存命中时直接返回数据,根本不需要发请求;二是重试逻辑的递归调用,因为重试需要重新走一遍完整链路。

我见过有的封装把缓存判断也放进请求拦截器,通过自定义 config 字段去分支判断,然后抛一个 Promise.reject 来“短路”。这样做确实能实现,但会干扰 pending 和 loading 的计数,还要额外标记“本次不是错误”。我自己试下来,在方法层判断缓存最干净:命中缓存直接 return,不污染拦截器的状态机。

1.3 目录设计与基础配置

我习惯把封装独立成一个目录,不要散落文件。下面这个结构足够清晰:

TEXT
src/
utils/
request/
index.js // 出口,创建实例 + 组装拦截器 + 方法层
config.js // 常量:超时时间、错误码映射、缓存 TTL
auth.js // token 存取与清除
loading.js // loading 计数器
cache.js // 缓存 Map 与 TTL 判断
retry.js // 重试逻辑

拆文件不是为了炫技,而是让每个模块的职责一眼能看出来。修改缓存策略时不用碰鉴权代码,排查 loading 问题时只需要看 loading.js。团队协作时也不容易产生冲突。

config.js 里我会放这些基础常量:

JS
export const DEFAULT_TIMEOUT = 10000 // 10 秒
export const DEFAULT_CACHE_TTL = 5 * 60 * 1000 // 5 分钟
export const DEFAULT_RETRY = 0 // 默认不重试
export const DEFAULT_RETRY_DELAY = 1000 // 重试基础延迟 1 秒
 
export const HTTP_ERROR_MAP = {
400: '请求参数错误',
401: '登录状态已过期,请重新登录',
403: '当前账号无权限操作',
404: '请求地址不存在',
500: '服务器内部错误',
502: '网关错误',
503: '服务暂不可用,请稍后重试',
504: '网关超时'
}

超时时间我给 10 秒,不是拍脑袋。后台管理系统的接口大多在 2 秒内返回,超过 10 秒基本可以判定为异常。设太短容易误杀慢查询,设太长用户等得焦虑。移动端或者弱网环境另说,通常要调到 15 到 20 秒。

2. 鉴权模块:token 注入与 401 兜底

2.1 token 存取与请求头注入

鉴权封装的第一个基础是 token 的存取。生产环境里 token 放 localStorage 还是 sessionStorage 取决于产品需求:如果是管理后台,关掉浏览器后希望重新登录,用 sessionStorage;如果希望下次打开还保持登录,用 localStorage。多数后台用的 localStorage。

auth.js 里有几个函数,逻辑非常简单但值得统一收口:

JS
const TOKEN_KEY = 'admin_token'
 
export function getToken() {
return localStorage.getItem(TOKEN_KEY) || ''
}
 
export function setToken(token) {
localStorage.setItem(TOKEN_KEY, token)
}
 
export function clearToken() {
localStorage.removeItem(TOKEN_KEY)
}

很多人会问:能不能把 token 直接放在内存变量里,比 localStorage 安全?内存变量确实能避免 XSS 通过 localStorage 偷取 token,但刷新页面就丢了,需要额外接口恢复登录态。大多数中后台项目并不需要这么高的安全等级,localStorage 加 HttpOnly Cookie 的方案看团队基础设施。我这里按通用方案走。

注入头的动作放在请求拦截器里。注意团队里要约定好后端要的字段名,是 Authorization: Bearer xxx 还是自定义头 X-Token: xxx。我项目里用的是 Authorization: Bearer,这也是最通用的格式。

JS
requestInterceptor = (config) => {
const token = getToken()
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
// 后续的指纹、pending、loading 都在这写
return config
}

2.2 401 统一拦截,但要防止重复跳转

响应拦截器里需要专门处理 HTTP 401。401 表示登录态失效,所有页面都会收到这个状态码,如果不做处理,会出现一个很经典的故障:页面里同时挂着三个接口,三个接口都返回 401,代码里每个错误处理分支都跳一次登录页,用户就被反复重定向,浏览器后退键直接失灵。

解决办法是加一个「跳转锁」。用模块级布尔变量记录是否已经在跳转,只有第一次 401 才执行跳转逻辑,后续 401 直接忽略。代码是这样:

JS
let isRedirecting = false
 
function handleUnauthorized() {
if (isRedirecting) return
isRedirecting = true
 
clearToken()
 
// 记录当前地址,登录后可以跳回原页面
const current = encodeURIComponent(window.location.href)
window.location.href = `/login?redirect=${current}`
}

什么时候重置这个布尔变量?两个时机:一是手动点击登录页跳转成功;二是退出登录时。否则用户登录成功后 isRedirecting 还是 true,下次 401 就不会再跳了。加一个 resetAuthState() 函数,在登录接口成功或退出登录时调用。

还有一个细节:如果项目用了 Vue Router 或 React Router,用 router.replace 跳转优先于 window.location.href,因为前者不刷新页面,能保留应用内部状态。但单页应用里的 router.replace 遇到 hash 模式有个问题——登录页地址不会带完整的原始路径,我习惯在 401 时保留 window.location.href 作为 redirect 参数,登录成功后整页刷新回去,对后端无感知。

2.3 HTTP 状态码与业务返回码的分层处理

这是封装里最容易被搞混的部分。HTTP 状态码是传输层状态,业务返回码是应用层状态。很多后端即使业务失败也会返回 HTTP 200,只在 body 里写 code: 50010。反过来,HTTP 401 也可能对应后端返回体的不同 code。

正确做法是分层判断。在响应成功分支里,判断 response.status 是否为 2xx,再判断 response.data.code 是否为 0(按你们后端约定)。两者都通过才算成功。

JS
// 成功分支
if (res.code !== 0) {
const businessError = new Error(res.message || '业务处理失败')
businessError.code = res.code
businessError.config = response.config
return Promise.reject(businessError)
}
return res

业务错误码的提示不能扔给 HTTP 错误映射表处理,因为后端业务码可能很多。我在 config.js 里维护一份 BUSINESS_ERROR_MAP,常用的放进去,未知 code 使用后端返回的 message 兜底。这样做的好处是提示语可以和后端解耦,后端改文案不用发版,前端也能对特定 code 做特殊逻辑,比如某个业务码需要打开新的引导弹窗。

3. 重复请求拦截与全局 Loading 管理

3.1 请求指纹:如何判断“同一个请求”

要拦截重复请求,第一步是给请求生成指纹。指纹的规则必须是:相同请求生成相同 key,不同请求生成不同 key。我用的字段是 method + url + params + data 的拼接。params 和 data 在序列化之前要先做一次 JSON.stringify,否则对象引用不同会导致 key 不一致。

JS
function getRequestKey(config) {
const { method, url, params, data } = config
const methodKey = method.toUpperCase()
const paramsKey = JSON.stringify(params || {})
const dataKey = JSON.stringify(data || {})
return `${methodKey}&${url}&${paramsKey}&${dataKey}`
}

这里有一个坑:JSON.stringify 对对象属性顺序很敏感,{ a: 1, b: 2 } 和 { b: 2, a: 1 } 会生成不同的 key。如果页面代码里两次请求的传参顺序不一致,就会被误判为不同请求,拦截失效。解决方法是写一个稳定序列化函数,对对象 key 排序后再序列化。项目接口相对规范的话,不排序也能用,但一旦出现上面这种情况排查起来很费劲。我用的是这种写法:

JS
function stableStringify(value) {
if (value === null || typeof value !== 'object') {
return JSON.stringify(value)
}
if (Array.isArray(value)) {
return `[${value.map(stableStringify).join(',')}]`
}
const keys = Object.keys(value).sort()
return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`
}

3.2 AbortController 取消上一个请求(防抖模式)

拿到指纹后,需要一个容器来登记“正在进行的请求”。我用的 Map<key, AbortController>,key 是请求指纹,value 是对应的取消控制器。

JS
const pendingMap = new Map()
 
function addPending(config) {
const key = getRequestKey(config)
const controller = new AbortController()
 
// 如果同一个 key 已有未完成的请求,取消它
const prevController = pendingMap.get(key)
if (prevController) {
prevController.abort()
}
 
config.signal = controller.signal
pendingMap.set(key, controller)
}
 
function removePending(config) {
const key = getRequestKey(config)
pendingMap.delete(key)
}

这里实现的是「取消上一个、保留最新」的抢占式策略。用户连续点击两次搜索,第一次请求发出后未返回,第二次点击到达时第一次请求被 abort,只保留第二次。这种策略对大多数 C 端场景更友好,因为用户可以快速重新触发,界面显示的是最新结果。

另一种策略是「丢弃本次、保留上一个」。第一次请求在途时,第二次点击直接短路返回上一次的 Promise,甚至从缓存里取值。这适合成本高的请求,比如重复提交表单。绝大多数场景我推荐抢占式,因为它实现简单,语义上也更符合“用户最后一次操作最重要”的原则。

取消请求会导致 axios 抛一个 CanceledError,这个错误会被响应错误分支捕获。需要判断 axios.isCancel(error),是取消错误就直接静默处理,不要弹错误提示,也不要走重试逻辑。后面踩坑部分我会专门说这个。

3.3 Loading 计数器:并发请求不能用一个 boolean

全局 Loading 用 boolean 控制是最大的坑。设想三个请求并发:第一个完成时想置 false,第二个还在飞,界面 Loading 就没了。正确方案是计数器。

JS
let pendingCount = 0
 
export function openLoading() {
if (pendingCount === 0) {
// 弹出全局 Loading
NProgress.start()
}
pendingCount++
}
 
export function closeLoading() {
if (pendingCount > 0) {
pendingCount--
}
if (pendingCount === 0) {
// 所有请求都结束了,关闭 Loading
NProgress.done()
}
}

计数器必须保证「每加一次就必减一次」。请求拦截器里 openLoading() 后,响应拦截器成功分支和错误分支都要 closeLoading()。如果某个分支因为 removePending 提前 return 忘了关闭,计数器就会泄漏,表现为 Loading 永远转圈。后面踩坑部分我会给出一个更容易排查的变体:给每次 Loading 加上短延迟防闪烁,比如请求在 300ms 内完成就不显示 Loading,避免高频刷新接口让 Loading 一直闪烁。

4. 缓存模块:TTL 缓存与手动失效

4.1 缓存对象设计

缓存模块我直接用 Map 实现,不引第三方库。每份缓存要记录三个信息:响应数据、存入时间戳、有效期(TTL)。建议所有缓存放在同一个 Map 里,按指纹做 key。

JS
const cacheMap = new Map()
 
export function getCache(key) {
const item = cacheMap.get(key)
if (!item) return null
 
const now = Date.now()
if (now - item.timestamp > item.ttl) {
cacheMap.delete(key)
return null
}
return item.data
}
 
export function setCache(key, data, ttl) {
cacheMap.set(key, {
data,
timestamp: Date.now(),
ttl: ttl || DEFAULT_CACHE_TTL
})
}

读取缓存时发现过期,直接删除并返回 null,保证不返回脏数据。为什么用 Map 而不是 Object?因为 Map 天然支持任意类型 key,删除和取值都是 O(1),而且不会受到原型链污染影响。另一个理由是 Map 有迭代顺序,将来要做 LRU 淘汰策略、按过期时间批量清理,Map 更方便。

4.2 缓存命中与写入时机

缓存的读和写时机是这套方案里最需要注意的。读时机放在方法层的开头,也就是真正调用 axios 实例之前。一旦命中缓存,整个链路都不需要走了,loading、pending 全部跳过。

写时机放在请求成功后。但注意不能凡是 GET 都缓存,有的接口虽然方法是 GET,但数据实时性要求很高,比如订单状态、库存数。我通过自定义 config 字段控制,只有显式声明 cache: true 的请求才参与缓存。

JS
async function request(config) {
const isGet = config.method.toUpperCase() === 'GET'
if (config.cache && isGet) {
const key = getRequestKey(config)
const cached = getCache(key)
if (cached !== null) {
return cached
}
}
 
const response = await axiosInstance(config)
 
if (config.cache && isGet) {
const key = getRequestKey(config)
setCache(key, response, config.cacheTtl || DEFAULT_CACHE_TTL)
}
 
return response
}

这里有一个设计取舍:写缓存的数据是 response.data 还是整个 response?我们项目的后端返回体是 { code, message, data },响应拦截器成功分支已经把 response.data 抛出来了,所以 request 函数拿到的 response 就是业务数据。直接把这份数据缓存即可。但要注意,缓存中保存的是对象引用。如果页面拿到缓存后直接修改了对象属性,缓存也会被污染。稳妥起见,写入缓存前做一次浅克隆 { ...response },虽然增加一点内存开销,但能避免绝大多数脏数据问题。

4.3 缓存穿透、缓存污染与手动刷新

缓存穿透最典型的表现是:同一时刻有 10 个页面在请求同一个列表接口,缓存还没有建立,10 个请求全部打到后端。这个问题在服务端缓存里叫 stampede,前端同样存在。解决方案有两个:要么在 pending 阶段就拦截,已经有一个同指纹请求在途时,后面的请求直接共享这个 Promise,也就是 singleflight;要么干脆接受这种现象,毕竟前端缓存场景下并发量通常不大。我在实际项目中是结合 pending 机制处理的,因为 pendingMap 本身就记录了在途请求,等第一个请求回来时把结果写入缓存,后面的请求自然就能命中。这个做法不用额外代码,只要保证缓存写入发生在 pending 移除之前就行。

缓存污染则是另一个问题。比如用户修改了个人资料,列表页还缓存着旧数据,刷新列表时拿到的是旧值。处理办法是提供手动失效接口。我在 cache.js 里导出一个 removeCache(key) 和 clearCache(),业务代码里修改完数据主动调一下。更优雅的方案是事件广播:用户数据变更后,发一个 CACHE_INVALIDATE 事件,全局缓存模块监听后根据规则清理。小项目用不上事件,直接 clearCache() 最省事。

JS
export function removeCache(key) {
cacheMap.delete(key)
}
 
export function clearCache() {
cacheMap.clear()
}

5. 统一错误处理与请求重试

5.1 错误分类:网络错误、超时、业务错误

统一错误处理的前提是把错误分类清楚。我分成四类:网络错误(断网、DNS 解析失败)、超时错误、业务错误(HTTP 200 但业务 code 非 0)、HTTP 状态码错误。每类的处理策略不同。

网络错误和超时错误要提示“网络异常,请检查网络”,同时可以考虑自动重试。HTTP 状态码错误按照 HTTP_ERROR_MAP 提示。业务错误使用业务码映射或后端 message。四类错误的共同出口是交给 notifyErrorMessage 函数。项目里如果用的 Element Plus,里面直接 ElMessage.error(msg);如果用 Antd,就是 message.error(msg)。我把这个函数放在 config 里导出,方便统一替换。

JS
let messageHandler = (msg) => {
console.error('[request error]', msg)
}
 
export function setMessageHandler(handler) {
messageHandler = handler
}
 
export function getMessageHandler() {
return messageHandler
}

UI 组件库千差万别,封装层不应该直接 import 某个库的组件。定义一套 messageHandler 注入机制,让项目入口把 ElMessage 或 antd 的 message 塞进来,封装层保持纯净。这是我后来重新整理时才明白的改进。

5.2 指数退避重试,但要守住幂等底线

请求重试是双刃剑。用得不好,后端慢查询没恢复,前端反而加大压力。重试策略必须满足两个前提:请求是幂等的、错误类型是可重试的。

幂等性判断很简单:只对 GET、HEAD、PUT、DELETE 做自动重试。POST 默认不重试,因为 POST 常用于创建订单、提交表单,重试可能造成重复提交。如果业务确有“POST 对账接口需要重试”的需求,在个别调用处显式传 retry: 2,前端开发者自己要承担重复提交的风险。

错误类型判断:4xx 业务错误不重试,5xx 和网络错误才重试。401 不重试。400 不重试,那是参数写错了,重试多少次都一样错。

指数退避公式是 delay = baseDelay * 2^retryCount。第一次重试等待 1 秒,第二次 2 秒,第三次 4 秒。这个递进速度可以在“快速恢复”和“避免压垮服务端”之间取得平衡。

JS
export async function retryRequest(error) {
const config = error.config
if (!config) return Promise.reject(error)
 
const maxRetry = config.retry || 0
const retryCount = config.__retryCount || 0
const isIdempotent = ['GET', 'HEAD', 'PUT', 'DELETE'].includes(config.method.toUpperCase())
const isRetryable = error.code === 'ECONNABORTED' || error.code === 'ERR_NETWORK' || (error.response && error.response.status >= 500)
 
if (retryCount >= maxRetry) return Promise.reject(error)
if (!isIdempotent) return Promise.reject(error)
if (!isRetryable) return Promise.reject(error)
 
const delay = (config.retryDelay || DEFAULT_RETRY_DELAY) * 2 ** retryCount
config.__retryCount = retryCount + 1
 
await sleep(delay)
return request(config)
}

sleep 函数很简单,return new Promise(resolve => setTimeout(resolve, ms))。重试时要注意:config 是已经注入过 token 和 pending 的旧配置,重新走 request 方法会再次走拦截器,token 会重新注入,pending 也会重新登记。没问题。但旧配置里可能带着上次的 signal,如果上次的 AbortController 还没取消,会带着旧 signal 发出请求。我通常在重试前把 config.signal 清掉,让新的拦截器重新绑定。

5.3 超时与取消的配合

axios 的 timeout 配置同时作用于整个请求生命周期。但超时和手动取消之间存在竞争:如果超时时间到了,axios 抛出 ECONNABORTED,这时配置里的 signal 已经没意义了。另一个坑是 timeout 默认值是 0,表示不超时,这会让用户一直等下去。我在实例里统一设了 10 秒默认,允许单个请求通过 config.timeout 覆盖。

超时的错误处理重试时还有一个细节:超时错误对象上,axios 会附带 error.code = 'ECONNABORTED'。重试函数里判断 'ECONNABORTED' 才能识别超时并触发重试。有些同学用 err.message.includes('timeout') 判断,这个很脆弱,因为不同环境下的超时文案不一样。统一用 error.code 判断最稳。

6. 完整代码示例与使用方式

6.1 封装文件完整代码(带逐行注释)

前面五章把每个模块拆开讲了,现在给一份整合后的完整代码。文件是 src/utils/request/index.js,所有模块合并在一个文件里方便复制。生产环境建议还是拆分到多文件。

JS
import axios from 'axios'
import { NProgress } from '@tanem/react-nprogress' // 示意,实际项目换成你用的 loading 方案
 
// ---------- 配置常量 ----------
const DEFAULT_TIMEOUT = 10000
const DEFAULT_CACHE_TTL = 5 * 60 * 1000
const DEFAULT_RETRY = 0
const DEFAULT_RETRY_DELAY = 1000
 
const HTTP_ERROR_MAP = {
400: '请求参数错误',
401: '登录状态已过期,请重新登录',
403: '当前账号无权限操作',
404: '请求地址不存在',
500: '服务器内部错误',
502: '网关错误',
503: '服务暂不可用,请稍后重试',
504: '网关超时'
}
 
// ---------- Token 管理 ----------
const TOKEN_KEY = 'admin_token'
 
function getToken() {
return localStorage.getItem(TOKEN_KEY) || ''
}
 
function setToken(token) {
localStorage.setItem(TOKEN_KEY, token)
}
 
function clearToken() {
localStorage.removeItem(TOKEN_KEY)
}
 
let isRedirecting = false
 
function handleUnauthorized() {
if (isRedirecting) return
isRedirecting = true
 
clearToken()
const current = encodeURIComponent(window.location.href)
window.location.href = `/login?redirect=${current}`
}
 
function resetAuthState() {
isRedirecting = false
}
 
// ---------- 全局 Loading 计数器 ----------
let pendingCount = 0
 
function openLoading() {
if (pendingCount === 0) {
NProgress.start()
}
pendingCount++
}
 
function closeLoading() {
if (pendingCount > 0) {
pendingCount--
}
if (pendingCount === 0) {
NProgress.done()
}
}
 
// ---------- 请求指纹 ----------
function stableStringify(value) {
if (value === null || typeof value !== 'object') {
return JSON.stringify(value)
}
if (Array.isArray(value)) {
return `[${value.map(stableStringify).join(',')}]`
}
const keys = Object.keys(value).sort()
return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`
}
 
function getRequestKey(config) {
const { method, url, params, data } = config
return [
method.toUpperCase(),
url,
stableStringify(params || {}),
stableStringify(data || {})
].join('&')
}
 
// ---------- 重复请求拦截(抢占式) ----------
const pendingMap = new Map()
 
function addPending(config) {
const key = getRequestKey(config)
const controller = new AbortController()
 
const prevController = pendingMap.get(key)
if (prevController) {
prevController.abort()
}
 
config.signal = controller.signal
pendingMap.set(key, controller)
}
 
function removePending(config) {
const key = getRequestKey(config)
pendingMap.delete(key)
}
 
// ---------- 缓存模块 ----------
const cacheMap = new Map()
 
function getCache(key) {
const item = cacheMap.get(key)
if (!item) return null
 
if (Date.now() - item.timestamp > item.ttl) {
cacheMap.delete(key)
return null
}
return item.data
}
 
function setCache(key, data, ttl) {
cacheMap.set(key, {
data: { ...data },
timestamp: Date.now(),
ttl: ttl || DEFAULT_CACHE_TTL
})
}
 
function removeCache(key) {
cacheMap.delete(key)
}
 
function clearCache() {
cacheMap.clear()
}
 
// ---------- 消息提示注入 ----------
let messageHandler = (msg) => {
console.error('[request error]', msg)
}
 
export function setMessageHandler(handler) {
messageHandler = handler
}
 
// ---------- 错误分类工具 ----------
function isCancelError(error) {
return axios.isCancel(error)
}
 
function isRetryableError(error) {
if (error.code === 'ECONNABORTED' || error.code === 'ERR_NETWORK') return true
return error.response && error.response.status >= 500
}
 
function notifyErrorMessage(error) {
let message = '请求失败,请稍后重试'
 
if (error.response) {
message = HTTP_ERROR_MAP[error.response.status] || `请求失败(HTTP ${error.response.status})`
} else if (error.code === 'ECONNABORTED') {
message = '请求超时,请检查网络后重试'
} else if (error.code === 'ERR_NETWORK') {
message = '网络异常,请检查网络连接'
}
 
if (error.businessCode) {
message = error.businessMessage || message
}
 
messageHandler(message)
}
 
// ---------- 重试逻辑 ----------
function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms))
}
 
async function retryRequest(error) {
const config = error.config
if (!config) return Promise.reject(error)
 
const maxRetry = config.retry || DEFAULT_RETRY
const retryCount = config.__retryCount || 0
 
const isIdempotent = ['GET', 'HEAD', 'PUT', 'DELETE'].includes(config.method.toUpperCase())
if (retryCount >= maxRetry || !isIdempotent || !isRetryableError(error)) {
return Promise.reject(error)
}
 
const delay = (config.retryDelay || DEFAULT_RETRY_DELAY) * 2 ** retryCount
config.__retryCount = retryCount + 1
 
// 清掉旧的 signal,让新的拦截器重新绑定
delete config.signal
 
await sleep(delay)
return request(config)
}
 
// ---------- axios 实例与拦截器 ----------
const axiosInstance = axios.create({
timeout: DEFAULT_TIMEOUT
// baseURL 根据项目环境注入,通常在 config 里单独管理
})
 
axiosInstance.interceptors.request.use(
(config) => {
// 1. 注入 token
const token = getToken()
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
 
// 2. 登记 pending(重复拦截)
addPending(config)
 
// 3. 打开全局 loading
openLoading()
 
return config
},
(error) => {
return Promise.reject(error)
}
)
 
axiosInstance.interceptors.response.use(
(response) => {
// 成功分支:移除 pending、关闭 loading
removePending(response.config)
closeLoading()
 
// 约定后端返回结构 { code, message, data }
const res = response.data
 
if (res.code !== 0) {
const businessError = new Error(res.message || '业务处理失败')
businessError.businessCode = res.code
businessError.businessMessage = res.message
businessError.config = response.config
return Promise.reject(businessError)
}
 
return res
},
async (error) => {
// 错误分支:取消错误直接静默
if (isCancelError(error)) {
removePending(error.config || {})
closeLoading()
return Promise.reject(error)
}
 
// 先收尾,避免 pending / loading 泄漏
if (error.config) {
removePending(error.config)
}
closeLoading()
 
// HTTP 401 处理
if (error.response && error.response.status === 401) {
handleUnauthorized()
return Promise.reject(error)
}
 
// 可重试的错误,走重试逻辑,不急着提示
if (error.config && (error.config.retry || DEFAULT_RETRY)) {
try {
return await retryRequest(error)
} catch (retryError) {
notifyErrorMessage(retryError)
return Promise.reject(retryError)
}
}
 
notifyErrorMessage(error)
return Promise.reject(error)
}
)
 
// ---------- 方法层出口 ----------
async function request(config) {
const method = (config.method || 'get').toUpperCase()
const isGet = method === 'GET'
 
// 缓存命中直接短路,不发请求
if (config.cache && isGet) {
const key = getRequestKey(config)
const cached = getCache(key)
if (cached !== null) {
return cached
}
}
 
const response = await axiosInstance(config)
 
// 请求成功后写入缓存
if (config.cache && isGet) {
const key = getRequestKey(config)
setCache(key, response, config.cacheTtl)
}
 
return response
}
 
// 便捷方法
request.get = (url, config = {}) => request({ ...config, method: 'GET', url })
request.post = (url, data, config = {}) => request({ ...config, method: 'POST', url, data })
request.put = (url, data, config = {}) => request({ ...config, method: 'PUT', url, data })
request.delete = (url, config = {}) => request({ ...config, method: 'DELETE', url })
 
// 导出鉴权工具
request.setToken = setToken
request.clearToken = clearToken
request.resetAuthState = resetAuthState
request.removeCache = removeCache
request.clearCache = clearCache
 
export default request

这个文件可以直接放到项目里用,替换原来散落的 axios 调用。

6.2 页面里的调用方式

用起来非常方便,普通请求不需要任何额外参数:

JS
const listData = await request.get('/api/user/list', { params: { page: 1 } })

需要缓存的 GET 接口,传 cache: true:

JS
const dict = await request.get('/api/dict/type/order_status', { cache: true })

修改了字典后,手动清干净:

JS
request.clearCache()

需要全局 Loading 和重复拦截是默认行为,不需要配置。需要关闭全局 Loading 的请求(比如上传进度条场景),传 loading: false,不过上面的代码还没有实现这个开关。实际项目里我会在拦截器里加个判断:

JS
if (config.loading !== false) {
openLoading()
}

请求超时或网络错误需要重试的,传 retry:

JS
const data = await request.get('/api/user/detail', {
retry: 2,
retryDelay: 1000
})

这样单个接口用了 2 次重试机会,每次基础间隔 1 秒。配合指数退避,实际等待时间分别是 1 秒和 2 秒。

7. 实测踩坑记录与常见问题速查

7.1 CanceledError 被当成错误提示

我第一次写完重复拦截时,发现控制台疯狂报错,页面上弹了无数“请求失败”。原因很简单:被 abort() 的请求会进入 axios 的错误分支,axios.isCancel(error) 判断写在了很多逻辑之后,导致取消错误先触发了 notifyErrorMessage。

修正方式是把 isCancelError 判断放最前面,取消错误不弹提示不重试,直接静默 reject。但注意,removePending 和 closeLoading 要照常执行,否则状态会泄漏。

这个坑还衍生出一个设计问题:第一个请求被取消时,调用方可能正在 await request.get(...) 的 try/catch 里,取消导致的 reject 会被业务代码捕获。如果业务代码把任何 reject 都当成错误处理,就会在页面里报一个无关错误。处理办法有两个,要么在业务侧判断 axios.isCancel,要么让被取消请求静默失败不触发调用方错误逻辑。我实际采用后者更多,因为改调用方成本太高。具体做法是在方法层捕获取消错误,直接返回一个特殊值,业务代码基本无感。

JS
async function request(config) {
try {
return await axiosInstance(config)
} catch (error) {
if (isCancelError(error)) {
return undefined
}
throw error
}
}

7.2 Loading 计数器泄漏的三个典型场景

Loader 一直转圈是封装上线后最容易出现的线上事故。我排查过三个典型场景。

第一个是请求拦截器抛错。如果拦截器在 openLoading() 之后、在 config 生效之前抛了异常,请求根本没发出去,响应拦截器也不会执行,计数器直接泄漏。解决方案是拦截器里所有可能抛错的分支都要 catch,并在 catch 里手动关闭 loading。

第二个是响应成功分支里 business code 非 0 的情况。有些同学在成功分支中发现业务码不对,直接 return Promise.reject,但忘记 removePending 和 closeLoading。这个能通过代码检查补掉。

第三个是带超时的取消。请求发出去后超时,错误对象上的 config.signal 是同一个 controller 的 signal。如果在超时错误分支里误判为取消而停止执行后续逻辑,要小心计数器一致性。

最实用的调试方法是在 closeLoading 里打日志,输出 pendingCount 和当前 URL。线上出现 Loading 卡死时,按时间线看日志,一眼就能找到哪个请求把计数器卡住了。

7.3 请求重试与并发重复请求叠加的坑

重试和 pending 拦截同时开启时,有个隐藏 bug。请求 A 第一次失败会触发重试,重试时 config 是旧对象,__retryCount 已经被 +1。但 pending 拦截器会根据指纹重新登记。如果这个请求还没完成,用户又触发了一次相同请求,第二次请求会 abort 掉正在重试的第一次请求,然后第一次请求的 retryRequest 捕获到 CanceledError,继续进入 retryRequest 判断。因为 isRetryableError 不认为取消错误可重试,会直接 reject。用户看到的表象是:重试中的请求被自己人给杀了。

解法是重试时对取消错误不做处理,直接放行,同时在 retryRequest 的入口加一个取消错误判断:

JS
if (isCancelError(error)) return Promise.reject(error)

这样避免了重试栈被取消请求反复触发,也让 pending 拦截更加稳定。

7.4 常见问题速查表

现象 原因 解决方案
页面反复跳登录页 多个 401 并发触发跳转逻辑 用 isRedirecting 布尔变量做跳转锁
Loading 永远转圈 某些错误分支没关闭计数器 统一在响应成功的两个分支和错误分支都执行 closeLoading
列表数据修改后还是旧值 GET 缓存未失效 手动调用 removeCache 或 clearCache
双击按钮提交了两次订单 POST 请求没有被重复拦截 对 POST 请求也做 pending 登记,或按钮侧防重复
同一个请求不同参数被误判为新请求 JSON.stringify 对 key 顺序敏感 使用 stableStringify 对 key 排序后再生成指纹
取消请求后页面报错 取消错误没有静默处理 axios.isCancel 判断放在最前,取消错误不提示不重试
重试时旧 signal 生效 旧 config 上绑定了 AbortController 重试前删除 config.signal
个别 GET 接口数据频繁变化 所有 GET 都缓存了 用 cache: true 显式开启缓存,不是默认开启
断网后多个请求立刻重试,压力过大 重试无间隔或间隔不合理 用指数退避 delay * 2^retryCount
部分接口不需要全局 Loading 所有请求都走了 Loading 流程 增加 config.loading === false 开关

7.5 一个提升体验的小技巧:请求去重时保留第一个请求的结果

重复拦截的抢占式策略有一个反直觉的时刻:第一个请求还没返回,用户误触发了第二次请求,第一次请求被取消,但是第二次请求可能因为参数相同,最终返回的数据其实是同一份。如果接口本身很慢,用户会感到“点了两下,转了两次圈”。这时候比较优雅的做法是保留第一次 Promise,让第二次请求直接复用同一个 Promise。这个模式叫 singleflight,虽然项目里不常用,但在缓存和重复拦截叠加时值得考虑。

实现上就是在 pendingMap 里不仅存 controller,还有一个 promise。第二次请求进入时发现已有在途 promise,直接 return 这个 promise。等结果回来时统一 resolve 给所有调用方。这个方案要注意 Promise 的错误传播:任何一个调用方 throw 都会影响其他调用方。所以还要用 Promise.prototype.finally 或 catch 包一层,保证只有第一个调用方负责清理工作。代码会稍微复杂一点,但确实是少见的优质优化点。

我在实际项目里遇到搜索框连续输入的场景,用了这个方案后,抖动感明显下降,服务器压力也小了一些。如果你的项目存在“同一参数短时间内被多处代码重复请求”的情况,强烈建议试一下。

这套封装整体下来,代码量不算大,但每行背后都对应真实线上踩过的坑。做完之后最大的收益是,新同学接手项目时只需要看 request/index.js 和 config.js,所有请求规则一目了然。相比之前散落各处的处理逻辑,这种集中式方案维护成本低太多了。如果你刚开始做 Axios 封装,建议先按六个模块逐个接入,别指望一步到位。先把鉴权和统一错误做了,再逐步加重复拦截和缓存,每加入一个模块都回归一遍全站请求,你会对这套东西的理解比抄一整份代码深得多。

基于Python+Open CV的手势识别算法设计
伴随着人工智能时代的到来,人机交互的领域也逐渐成为研究的一大方向;其中,手势识别是人机交互领域的一项关键技术,自此手势识别也迎来了一波高潮,近几年无论是在消费领域、电子领域、数码领域、家电领域甚至汽车领域上,都能或多或少的见到手势识别的身影。 手势识别在设计智能高效的人机界面方面具有至关重要的作用, 目前手势识别已应用到手语识别、智能监控、到虚拟现实等各个领域,手势识别的原理都是利用各种传感器(例如红外、摄像头等)对手部的形态进行捕捉并进行建模,形成一个模型信息的序列帧,而后将这些信息序列转换为机器能够识别的相对应指令(例如打开、切换菜单、移动等)来完成控制。 采用Python的集成开发环境Pycharm进行本次课程设计,在Pycharm中进行需要库(模块)的下载,调取电脑摄像头,按帧读取摄像头采集到的头像,形态学处理,图像旋转(由于摄像头采集到的图像是镜像,需要用cv2.flip将摄像头采集到的图像进行处理),选取图片中固定位置作为手势输入,用红线画出手势识别框,基于hsv的肤色检测,进行高斯滤波,找出轮廓,求出图像中手势的凹凸点,手指间角度求取。
努力学习前端的小陈
ArcGIS Pro入门制图教程
地理信息系统 (GIS) 是一种使用地图显示和分析数据的方式。在本教程中,您将学习桌面 GIS 应用程序 ArcGIS Pro 的基础知识。新加坡的一家旅行社希望制作一款宣传册,用于向游客介绍距离市中心热门目的地最近的火车站。该宣传册将与带有文本信息的地图相结合,并在城市的自助设备中出售。您将帮助该旅行社绘制旅游景点的地图,分析其与火车站的距离以及更改地图的外观以使其在视觉上更具吸引力。在 ArcGIS Pro 中,地图和数据通常被组织在一个工程中。开始制作地图之前,您将创建一个工程。
科研online
ArcGIS Pro 布局创建与地图加载全流程解析
本文详细解析了ArcGIS Pro中布局创建与地图加载的全流程。针对从ArcMap转来的用户,重点阐述了布局与地图解耦的核心设计理念,并提供了从新建布局、设置参考比例尺、加载地图框到深度控制与精细化排版的实用技巧,帮助用户高效制作专业地图。
您的账号已被封禁
ArcGIS PRO布局视图避坑指南:地图框添加与专题图制作的5个关键步骤
本文针对ArcGIS PRO用户在布局视图中制作专题图时遇到的常见问题,提供了地图框添加与专题图制作的5个关键步骤避坑指南。从理解布局视图思维、数据框预处理、地图元素协同配置,到深化视觉层次与最终输出检查,系统讲解了如何高效产出严谨美观的专业地图,帮助用户跨越从数据分析到地图输出的最后一公里。
冰炭不同炉
ROS-CV-ImageConverter:将ROS图像转换为OpenCV(cv :: Mat)类型的图像
ROS-CV图像转换器 依存关系 cv_bridge(ROS软件包)
Willis Wang
计算机视觉图像处理-CV2与图像插值算法
用最近邻插值与双线性插值原理完成图像缩放 最近邻插值,是指将目标图像中的点,对应到源图像中后,找到最相邻的整数点,作为插值后的输。缺点:使用最近邻插值算法处理图像放大时,在图象中可能出现明显的块状效应 双线性插值,在两个方向上做三次线性插值。使用双线性插值算法处理图像放大时,在图象中可能出现马赛克 代码 import cv2 img = cv2.imread(’./xiabang.jpg’, cv2.IMREAD_UNCHANGED) #缩放比例 scale_percent = 0.3 width = int(img.shape[1] * scale_percent) height = int
weixin_38697274
基于水平集CV模型的图像分割(Matlab代码)
基于水平集CV模型的图像分割(Matlab代码),全套代码
小宇QAQ
导向滤波(guide_filter)的python实现
导向滤波(guide_filter)的python实现,可以结合暗通道;理论实现比较好的图像去噪效果。
zachzhan_g
ArcGIS Pro 如何新建布局
你是否已经习惯了在ArcGIS中数据视图和布局视图之间来回切换,到了ArcGIS Pro中却找不到二者之间切换的按钮,即使新建布局后却发现地图怎么却是一片空白。从上面的图中可以看到,虽然新建了布局,但是地图还是空白的,如果想要显示地图还需要加载一下,将地图加载进来。在新建的布局上绘制一个框,作为地图显示的范围,绘制后可以看到地图已经完成加载,如下图所示。在菜单栏上选择插入,点击新建布局下拉箭头,选择一个合适的尺寸,如下图所示。点击后完成布局的新建,新建的布局如下图所示。
水经注GIS
ArcGIS Pro数据修复与图层管理实战指南
本文是ArcGIS Pro数据修复与图层管理的实战指南。针对数据源丢失导致的“红色叹号”问题,详细讲解了一键批量修复和进阶手动修复策略,并分享了使用相对路径、打包工程等防患于未然的黄金法则。同时,深入介绍了如何利用图层组进行高效的地图内容组织、比例尺控制与批量操作,帮助用户构建清晰、智能的专业地图,大幅提升GIS项目管理效率。
Tomato
ArcGIS Pro布局设计实战:从空白页面到专业地图输出的完整工作流
本文详细解析了ArcGIS Pro中从“新建布局”开始,到输出专业地图的完整工作流。内容涵盖布局哲学、地图框深度运用、制图元素集成及视觉排版等核心环节,旨在帮助中级用户掌握项目驱动的现代化制图方法,实现从数据到出版级地图的精准转化。
AnjneyMidha
ArcGIS PRO布局视图避坑指南:地图框添加与坐标系设置的5个常见错误
本文针对ArcGIS PRO用户在布局视图中常遇的难题,重点解析了地图框添加与坐标系设置的5个常见错误。从地图框的创建逻辑、坐标系冲突的根源剖析,到地图范围控制、元素联动更新以及打印导出设置,提供了一套完整的避坑指南与实战解决方案,帮助用户高效、精准地完成地图制图与输出工作。
重离子猫猫
ArcGIS Pro布局设计避坑指南:为什么你的地图总是显示空白?
本文深入解析ArcGIS Pro布局设计中地图显示空白的常见问题,提供从基础操作到高级排错的完整解决方案。重点讲解地图框的正确使用方法、布局元素配置技巧,以及多地图框协同工作等进阶功能,帮助用户快速掌握专业地图制作的核心技术。
习翔宇
CV算法(MATLAB)
chan 和 vese 提出的经典CV模型
beastLOVE
GrabCut:使用opencv-python cv2.grabCut交互式剪切图像
GrabCut 使用opencv-python cv2.grabCut交互式剪切图像
Aaron Gary
Opencv-Python图像透视变换cv2.warpPerspective的示例
今天小编就为大家分享一篇关于Opencv-Python图像透视变换cv2.warpPerspective的示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
weixin_38711369
leetcodecv-Kylin:CV算法岗面经&LeetCode刷题总结
leetcode cv Kylin CV算法岗面经 & LeetCode刷题总结 不断更新中。。。。 面试&笔试经验 LeetCode
weixin_38499553
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS.pdf
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS真的很不错,
weixin_43905342
ArcGIS布局视图方向调整与优化技巧
地图布局方向是GIS制图的基础设置,直接影响空间数据的可视化效果。横向(Landscape)和竖向(Portrait)布局通过调整页面长宽比例,可优化不同地理要素的展示方式。在ArcGIS等专业制图软件中,方向设置会联动影响比例尺、图例等核心元素的自动适配逻辑。本文以A4纸张为例,详解通过页面设置、Python脚本批处理等技术手段实现布局方向的高效调整,并针对比例尺失准、图例溢出等典型问题提供工程解决方案。特别适用于带状区域地图制作等需要最大化利用版面空间的场景,可提升40%以上的图面利用率。
塞音菩光
ArcGIS Pro 3.4必学新功能:符号系统与布局视图的可见性联动(含省时技巧)
ArcGIS Pro 3.4引入了符号系统与布局视图的可见性联动功能,通过唯一值符号化和复选框控制,实现原子级要素显示/隐藏。这一创新极大提升了制图效率,支持在符号系统窗格、内容窗格和布局视图中同步操作,特别适合城市规划、环境监测等需要动态展示的场景。
t8u9v0
ArcGIS Pro 布局创建与地图加载全攻略
本文详细解析了ArcGIS Pro中布局与地图分离的设计哲学,并提供了从新建布局到加载地图的完整操作指南。重点介绍了如何通过“插入”选项卡新建布局、选择合适的页面尺寸,以及使用地图框工具将项目中的地图动态链接至布局。文章还涵盖了地图范围控制、比例尺锁定、图例添加等深度定制技巧,帮助用户高效创建专业地图并导出为高质量成果。
milk8
ArcGIS多图布局实战:从数据框管理到批量导出的完整指南
在地理信息系统(GIS)制图领域,将多张地图高效整合到单一版面是提升分析报告专业性与表现力的关键技术。其核心原理在于理解并运用数据框与布局视图的分离机制,通过独立的数据框承载不同区域或专题的地理数据,并在统一的布局视图中进行精确排版与视觉整合。这项技术的核心价值在于实现了制图流程的标准化与自动化,避免了传统拼图方式带来的效率低下与更新困难问题,尤其适用于区域对比、时间序列分析、综合评估报告等需要多视角、多维度展示地理信息的应用场景。本文聚焦于ArcGIS Pro平台,深入剖析了多图布局中数据框范围联动、地图
aaa1231722
monolithic-cv:CV算法的集合
单片-cv 计算机视觉算法转储
晨曦姜
改进的cv图像分割
改进的cv图像分割,对学习cv模型有帮助
a904235765
C++实现基于暗通道与导向滤波的图像去雾算法
资源下载链接为: https://pan.quark.cn/s/1bfadf00ae14 在图像处理领域,图像去雾技术用于消除大气散射导致的模糊,提升图像清晰度和视觉质量。本文将介绍一种基于暗通道和导向滤波的图像去雾算法,并探讨如何使用C++和OpenCV库实现。 暗通道理论由Jia等人于2006年提出。他们发现自然场景中存在一些低亮度像素,通常位于无直射光区域。这些像素被称为暗通道像素,可用于估计大气散射模型中的透射率。具体方法是将图像分块,在每块中找到最暗像素值作为暗通道像素。 大气散射模型是图像去雾的基础,描述了光线在大气中传播时的散射影响。模型公式为: I(x)=T(x)×J(x)+A×(1−T(x)) 其中,T(x)是透射率,J(x)是无雾图像亮度,A是全局大气光。透射率与散射程度成反比,无雾图像亮度反映物体本身色彩。 利用暗通道先验,可以近似估计透射率。假设D(x)为暗通道像素,透射率T(x)可通过迭代公式计算: T k+1 (x)= max(D)+ϵ D(x) +(1− max(D)+ϵ D(x) )×T k (x) 其中,k是迭代次数,ϵ是小常数,用于避免除零。 估计透射率后,使用导向滤波器平滑透射率图,减少噪声和边缘失真。导向滤波是一种自适应局部滤波方法,可保持图像边缘细节,同时进行平滑处理。在图像去雾中,它根据图像梯度信息指导滤波过程,更好地恢复图像清晰度。 通过大气散射模型,可得到去雾后的图像: J out (x)= T(x) I(x)−A×(1−T(x)) +A 在C++中,可借助OpenCV库处理图像数据。首先读取输入图像,然后提取暗通道,估计透射率,应用导向滤波,最终恢复无雾图像。OpenCV提供了丰富的图像处理函数,如cv::split用于分离通道,cv::min用于找最小值,cv::filter2D用于导向滤波,cv::imwrite用于保存
KaiyuanCode
cv模型图像分割matlab源程序
cv模型 matlab 图像分割源码,逻辑清晰,注释详尽。
phoenix01
CV图像分割
从pud找到的CV图像分割代码,代码的通过较少的迭代次数就可以实现图像的分割,对学习CV分割有帮助。
a904235765
ArcGIS Pro 3.0 布局视图实战:5分钟搞定专业地图的图例、比例尺与指北针
本文详细介绍了ArcGIS Pro 3.0布局视图的实战技巧,帮助用户在5分钟内高效添加图例、比例尺与指北针,打造专业地图。通过智能图例、动态比例尺和现代化指北针设计,提升制图效率与美观度,特别适合GIS初学者和从ArcMap迁移的用户。
weixin_30652491
ArcGIS Pro界面突然消失?3种恢复方法+自定义布局技巧
本文针对ArcGIS Pro用户常见的操作界面元素突然消失问题,提供了三种核心恢复方法:通过“视图”功能区一键唤回、利用“重置窗格”命令恢复默认布局,以及通过应用程序设置进行深度恢复。文章还深入讲解了如何通过停靠、分组窗格以及自定义功能区等技巧,打造高效个性化的操作界面,帮助用户从被动解决问题转向主动优化工作环境。
nnn11
最优化学习笔记1——关于拟牛顿法推导
从2020年3月份到现在,一年的时间里断断续续自学最优化,结合豆瓣读书、知乎等网站上的推荐,翻阅了以下书和课程: Stephen Boyd和Lieven Vandenberghe的《Convex Optimization》,这本书被公认为学习凸优化的必读经典著作,其中大量的篇幅讲应用,讲理论和算法的篇幅稍少一些。在B网站上有Boyd的视频课程,油管上也有,不过只有英文字幕,如果是零基础接触,直接看Boyd的视频稍显费劲,B站上也有凌青老师以《Convex Optimization》为教材的讲解,推荐作为入
xiaofei473