620 lines
16 KiB
Plaintext
620 lines
16 KiB
Plaintext
// simple-http.uts
|
||
// 简单强大的 UniappX UTS 网络请求封装
|
||
// 支持 token 管理、无感刷新、多方法兼容
|
||
// ================ 类型定义 ================
|
||
// 响应接口
|
||
import HttpError, {
|
||
IResponse, IRequestOption, IHttpError, IFileInfo, INetworkInfo, IDownRespone, IUploadInfo, IUploadOption, IUploadResult, IResponseToken
|
||
} from "@/types/http.uts"
|
||
|
||
import userState, { getUserToken, setUserToken, clearToken } from '@/stores/user.uts'
|
||
|
||
// ================ 简单 HTTP 请求类 ================
|
||
class SimpleHttp {
|
||
|
||
// 配置
|
||
private baseOptions : UTSJSONObject = {
|
||
baseURL: 'http://localhost:8000',
|
||
timeout: 15000,
|
||
tokenKey: 'access_token',
|
||
refreshTokenKey: 'refresh_token',
|
||
tokenExpireKey: 'token_expire',
|
||
tokenType: 'Bearer',
|
||
enableRefreshToken: true,
|
||
maxRetryCount: 3,
|
||
retryDelay: 1000,
|
||
debug: true
|
||
} as UTSJSONObject
|
||
// 状态
|
||
private isRefreshing = false
|
||
private refreshSubscribers : Array<() => void> = []
|
||
private requestQueue : Array<() => Promise<any>> = []
|
||
private isProcessingQueue = false
|
||
constructor(options : UTSJSONObject = {}) {
|
||
this.baseOptions = { ...this.baseOptions, ...options }
|
||
this.setupNetworkListener()
|
||
}
|
||
// ================ 核心请求方法 ================
|
||
/**
|
||
* 发送请求
|
||
*/
|
||
async request(options : IRequestOption) : Promise<IResponse> {
|
||
try {
|
||
//await this.checkNetwork() // 检查网络
|
||
if (options.showLoading != null && options.showLoading == true) {
|
||
uni.showLoading({
|
||
title: options.loadingText ?? '加载中...',
|
||
mask: true
|
||
})
|
||
}
|
||
const requestConfig = this.buildRequestConfig(options)
|
||
const response = await this.sendRequest(requestConfig)
|
||
|
||
const { statusCode, data } = response
|
||
if (statusCode >= 200 && statusCode < 300 && data != null) {
|
||
if (data?.access_token != null) {
|
||
const access_token = data.access_token ?? ''
|
||
const access_expired = data.access_expired ?? 0
|
||
const refresh_token = data.refresh_token ?? ''
|
||
const refresh_expired = data.refresh_expired ?? 0
|
||
setUserToken(access_token, access_expired, refresh_token, refresh_expired)
|
||
}
|
||
return Promise.resolve(data)
|
||
}
|
||
else if (statusCode == 401) {
|
||
return this.handleTokenExpired(options)
|
||
} else {
|
||
throw HttpError({
|
||
errCode: statusCode,
|
||
errMsg: `HTTP 错误: ${statusCode}`,
|
||
options: options
|
||
})
|
||
}
|
||
} catch (error) {
|
||
console.log(error)
|
||
throw HttpError({
|
||
errCode: 5000,
|
||
options,
|
||
cause: error as Error
|
||
})
|
||
} finally {
|
||
if (options.showLoading != null && options.showLoading == true) {
|
||
uni.hideLoading()
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* GET 请求
|
||
*/
|
||
async get(url : string, data : any = {}, config : IRequestOption = { url: '' }) : Promise<IResponse> {
|
||
//const mergedConfig = config != null ? config : { url: '' }
|
||
return this.request({
|
||
...(config),
|
||
url,
|
||
method: 'GET',
|
||
data
|
||
} as IRequestOption)
|
||
}
|
||
|
||
/**
|
||
* POST 请求
|
||
*/
|
||
async post(url : string, data : any = {}, config : IRequestOption = { url: '' }) : Promise<IResponse> {
|
||
//const mergedConfig = config != null ? config : { url: '' }
|
||
return this.request({
|
||
...(config),
|
||
url,
|
||
method: 'POST',
|
||
data
|
||
} as IRequestOption)
|
||
}
|
||
|
||
/**
|
||
* PUT 请求
|
||
*/
|
||
async put(url : string, data : any = {}, config : IRequestOption = { url: '' }) : Promise<IResponse> {
|
||
//const mergedConfig = config != null ? config : { url: '' }
|
||
return this.request({
|
||
...(config),
|
||
url,
|
||
method: 'PUT',
|
||
data
|
||
})
|
||
}
|
||
|
||
/**
|
||
* DELETE 请求
|
||
*/
|
||
async delete(url : string, data ?: any, config : IRequestOption = { url: '' }) : Promise<IResponse> {
|
||
//const mergedConfig = config != null ? config : { url: '' }
|
||
return this.request({
|
||
...(config),
|
||
url,
|
||
method: 'DELETE'
|
||
} as IRequestOption)
|
||
}
|
||
|
||
/**
|
||
* PATCH 请求
|
||
*/
|
||
async patch(url : string, data ?: any, config : IRequestOption = { url: '' }) : Promise<IResponse> {
|
||
//const mergedConfig = config != null ? config : { url: '' }
|
||
return this.request({
|
||
...(config),
|
||
url,
|
||
method: 'PATCH',
|
||
data
|
||
} as IRequestOption)
|
||
}
|
||
|
||
|
||
/**
|
||
* 检查 Token 是否有效
|
||
*/
|
||
isTokenValid() : boolean {
|
||
const token = getUserToken()
|
||
return (token != null)
|
||
}
|
||
|
||
|
||
// ================ Token 无感刷新 ================
|
||
|
||
/**
|
||
* 刷新 Token
|
||
*/
|
||
private async refreshToken() : Promise<boolean> {
|
||
if (this.isRefreshing) {
|
||
return new Promise((resolve) => {
|
||
this.refreshSubscribers.push(() => resolve(true))
|
||
})
|
||
}
|
||
this.isRefreshing = true
|
||
try {
|
||
const tokenResult = getUserToken()
|
||
if (tokenResult == null) {
|
||
clearToken()
|
||
this.goToLogin()
|
||
return false
|
||
}
|
||
const { refreshToken } = tokenResult
|
||
if (refreshToken == null) {
|
||
this.log('无刷新 Token')
|
||
clearToken()
|
||
this.goToLogin()
|
||
return false
|
||
}
|
||
// 调用刷新接口（需后端实现 Login::refresh 并返回 { access_token, refresh_token, ... }）
|
||
const response = await this.post('/wxchat/api/login/refresh', {
|
||
refresh_token: refreshToken
|
||
}, {
|
||
url: "",
|
||
needToken: false,
|
||
showLoading: false
|
||
})
|
||
if (response.code == 0) {
|
||
const { access_token, access_expired, refresh_token, refresh_expired } = response
|
||
setUserToken(access_token ?? '', access_expired ?? 0, refresh_token ?? '', refresh_expired ?? 0)
|
||
// 通知所有等待的请求
|
||
this.refreshSubscribers.forEach(callback => callback())
|
||
this.refreshSubscribers = []
|
||
return true
|
||
} else {
|
||
this.log('刷新 Token 失败:', response.message)
|
||
clearToken()
|
||
this.goToLogin()
|
||
return false
|
||
}
|
||
} catch (error) {
|
||
this.log('刷新 Token 异常:', error)
|
||
clearToken()
|
||
this.goToLogin()
|
||
return false
|
||
} finally {
|
||
this.isRefreshing = false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理 Token 过期
|
||
*/
|
||
private async handleTokenExpired(options : IRequestOption) : Promise<IResponse> {
|
||
if (this.baseOptions.enableRefreshToken == null) {
|
||
throw HttpError({
|
||
errCode: 401,
|
||
errMsg: 'Token 已过期',
|
||
options: options
|
||
})
|
||
}
|
||
const success = await this.refreshToken()
|
||
if (success) {
|
||
return this.request(options)
|
||
} else {
|
||
throw HttpError({
|
||
errCode: 401,
|
||
errMsg: '登录已过期，请重新登录',
|
||
options: options
|
||
})
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 跳转到登录页
|
||
*/
|
||
private goToLogin() : void {
|
||
uni.showModal({
|
||
title: '登录提示',
|
||
content: '登录已过期，请重新登录',
|
||
showCancel: false,
|
||
confirmText: '去登录',
|
||
success: () => {
|
||
uni.reLaunch({
|
||
url: '/pages/login/index'
|
||
})
|
||
}
|
||
})
|
||
}
|
||
|
||
// ================ 请求处理 ================
|
||
|
||
/**
|
||
* 构建请求配置
|
||
*/
|
||
private buildRequestConfig(options : IRequestOption) : IRequestOption {
|
||
const { url, contentType } = options
|
||
options.url = url?.startsWith('http') == true ? url! : `${this.baseOptions.baseURL}${url?.startsWith('/') == true ? url! : '/' + (url ?? '')}`
|
||
if (options.header == null) {
|
||
options.header = {} as UTSJSONObject
|
||
}
|
||
// #ifdef APP
|
||
const sysInfo = uni.getSystemInfoSync()
|
||
options.header['App-Platform'] = sysInfo.osName
|
||
options.header['App-Version-Code'] = sysInfo.appVersionCode
|
||
options.header['App-Version-Name'] = sysInfo.appVersion
|
||
options.header['App-Channel'] = sysInfo.osName
|
||
options.header['App-Device-ID'] = sysInfo.deviceId
|
||
options.header['App-Device-Model'] = sysInfo.deviceModel
|
||
options.header['App-OS-Version'] = sysInfo.osVersion
|
||
// #endif
|
||
switch (contentType) {
|
||
case 'json':
|
||
options.header['Content-Type'] = 'application/json'
|
||
break
|
||
case 'form':
|
||
options.header['Content-Type'] = 'application/x-www-form-urlencoded'
|
||
break
|
||
case 'multipart':
|
||
options.header['Content-Type'] = 'multipart/form-data'
|
||
break
|
||
}
|
||
if (options.needToken != null && options.needToken) {
|
||
const tokenResult = getUserToken()
|
||
if (tokenResult != null) {
|
||
const { accessToken } = tokenResult
|
||
if (accessToken != null) {
|
||
options.header['Authorization'] = `${this.baseOptions.tokenType} ${accessToken}`
|
||
}
|
||
}
|
||
}
|
||
return options;
|
||
}
|
||
|
||
/**
|
||
* 发送请求
|
||
*/
|
||
private async sendRequest(options : IRequestOption) : Promise<RequestSuccess<IResponse>> {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request<IResponse>({
|
||
url: options.url,
|
||
data: options.data,
|
||
header: options.header,
|
||
method: options.method,
|
||
timeout: options.timeout,
|
||
enableChunked: true,
|
||
success: (res : RequestSuccess<IResponse>) => {
|
||
resolve(res)
|
||
},
|
||
fail: (err : RequestFail) => {
|
||
reject(HttpError({
|
||
errCode: err.errCode,
|
||
errMsg: err.errMsg,
|
||
options: options,
|
||
}))
|
||
},
|
||
complete: (option : any) => {
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// ================ 网络状态 ================
|
||
|
||
/**
|
||
* 检查网络状态
|
||
*/
|
||
private async checkNetwork() : Promise<void> {
|
||
return new Promise((resolve, reject) => {
|
||
uni.getNetworkType({
|
||
success: (res) => {
|
||
if (res.networkType === 'none') {
|
||
reject(new Error('网络连接已断开'))
|
||
} else {
|
||
resolve()
|
||
}
|
||
},
|
||
fail: () => {
|
||
resolve() // 网络检查失败不阻止请求
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 获取网络信息
|
||
*/
|
||
async getNetworkInfo() : Promise<INetworkInfo> {
|
||
return new Promise((resolve) => {
|
||
uni.getNetworkType({
|
||
success: (res) => {
|
||
resolve({
|
||
isConnected: res.networkType !== 'none',
|
||
networkType: res.networkType,
|
||
isWifi: res.networkType == 'wifi',
|
||
isCellular: ['2g', '3g', '4g', '5g'].includes(res.networkType)
|
||
})
|
||
},
|
||
fail: () => {
|
||
resolve({
|
||
isConnected: false,
|
||
networkType: 'unknown',
|
||
isWifi: false,
|
||
isCellular: false
|
||
})
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 设置网络监听
|
||
*/
|
||
private setupNetworkListener() : void {
|
||
uni.onNetworkStatusChange((res) => {
|
||
if (!res.isConnected) {
|
||
uni.showToast({
|
||
title: '网络连接已断开',
|
||
icon: 'none',
|
||
duration: 3000
|
||
})
|
||
}
|
||
})
|
||
}
|
||
|
||
// ================ 工具方法 ================
|
||
/**
|
||
* 日志记录
|
||
*/
|
||
private log(...args : any[]) : void {
|
||
if (this.baseOptions.debug != null && this.baseOptions.debug == true) {
|
||
console.log('[SimpleHttp]', ...args)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 设置基础 URL
|
||
*/
|
||
setBaseURL(baseURL : string) : void {
|
||
this.baseOptions.baseURL = baseURL
|
||
}
|
||
|
||
/**
|
||
* 设置超时时间
|
||
*/
|
||
setTimeout(timeout : number) : void {
|
||
this.baseOptions.timeout = timeout
|
||
}
|
||
|
||
/**
|
||
* 设置调试模式
|
||
*/
|
||
setDebug(debug : boolean) : void {
|
||
this.baseOptions.debug = debug
|
||
}
|
||
|
||
/**
|
||
* 设置 Token 刷新开关
|
||
*/
|
||
setEnableRefreshToken(enable : boolean) : void {
|
||
this.baseOptions.enableRefreshToken = enable
|
||
}
|
||
|
||
/**
|
||
* 获取配置
|
||
*/
|
||
getConfig() : UTSJSONObject {
|
||
return { ...this.baseOptions }
|
||
}
|
||
// ================ 上传和下载 ================
|
||
|
||
/**
|
||
* 上传文件
|
||
*/
|
||
async upload(options : IUploadOption, onProgress ?: (current : number, total : number, percent : number) => void) : Promise<IResponse> {
|
||
let { url, filePath, name = 'file', formData, header } = options
|
||
const headers : UTSJSONObject = {
|
||
...(header ?? {} as UTSJSONObject)
|
||
}
|
||
const tokenResult = getUserToken()
|
||
if (tokenResult != null) {
|
||
const { accessToken } = tokenResult
|
||
if (accessToken != null) {
|
||
{
|
||
headers['Authorization'] = `${this.baseOptions.tokenType} ${accessToken}`
|
||
}
|
||
}
|
||
}
|
||
return await new Promise((resolve, reject) => {
|
||
const uploadTask = uni.uploadFile({
|
||
url: url.startsWith('http') ? url : `${this.baseOptions.baseURL}${url}`,
|
||
filePath,
|
||
name,
|
||
formData: formData ?? {},
|
||
header: headers,
|
||
success: (response : UploadFileSuccess) => {
|
||
const { statusCode, data } = response
|
||
// 处理 HTTP 204 等无内容响应
|
||
if (statusCode == 204 || data == null) {
|
||
//resolve({ code: 0, message: 'success', data: null } as IResponse)
|
||
reject(HttpError({ errCode: -1, errMsg: `响应解析失败，原始数据>: ${data.substring(0, 200)}`, options }))
|
||
}
|
||
if (statusCode >= 200 && statusCode < 300) {
|
||
try {
|
||
const obj = JSON.parse(data) as UTSJSONObject;
|
||
let resInfo = obj.parse<IResponse>()
|
||
|
||
const { access_token, access_expired, refresh_token, refresh_expired } = resInfo!!
|
||
if (resInfo?.access_token != null) {
|
||
setUserToken(access_token ?? '', access_expired ?? 0, refresh_token ?? '', refresh_expired ?? 0)
|
||
}
|
||
if (resInfo != null) {
|
||
resolve(resInfo)
|
||
}
|
||
// // 业务状态码判断（根据你的业务逻辑调整）
|
||
if (resInfo?.code != 0 && resInfo?.code != 200) {
|
||
reject(HttpError({ errCode: resInfo?.code ?? 500, errMsg: resInfo?.message ?? '业务错误', options }))
|
||
}
|
||
} catch (parseError) {
|
||
console.log(parseError)
|
||
// 返回的不是 JSON，可能是之前遇到的响应头问题
|
||
reject(HttpError({ errCode: -1, errMsg: `响应解析失败，原始数据: ${data.substring(0, 200)}`, options }))
|
||
}
|
||
return
|
||
}
|
||
// 401 未授权处理
|
||
if (statusCode == 401) {
|
||
// if (this.baseOptions.enableRefreshToken) {
|
||
// try {
|
||
// // const refreshSuccess = await this.refreshToken()
|
||
// // if (refreshSuccess) {
|
||
// // // 重试上传
|
||
// // const retryResult = await this.upload<T>(options)
|
||
// // resolve(retryResult)
|
||
// // return
|
||
// // }
|
||
// } catch (refreshError) {
|
||
// // refreshToken 失败，继续走登录过期逻辑
|
||
// }
|
||
// }
|
||
reject(HttpError({ errCode: 401, errMsg: '登录已过期，请重新登录', options }))
|
||
|
||
}
|
||
// 其他 HTTP 错误
|
||
reject(HttpError({ errCode: statusCode, errMsg: `HTTP 错误: ${statusCode}`, options }))
|
||
},
|
||
fail: (error : UploadFileFail) => {
|
||
console.log(error)
|
||
reject(HttpError({ errCode: error.errCode ?? -1, errMsg: error.errMsg ?? '上传失败', options }))
|
||
}
|
||
})
|
||
uploadTask.onProgressUpdate((res) => {
|
||
console.log('上传进度', res.progress)
|
||
})
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 并行上传多个文件
|
||
*/
|
||
async uploadMultipleFilesParallel(options : IUploadOption, files : IFileInfo[]) : Promise<IFileInfo[]> {
|
||
// 显式指定 map 回调的返回类型为 Promise<IFileInfo>
|
||
const uploadPromises = files.map((file) : Promise<IFileInfo> => {
|
||
// 显式指定 upload 的泛型参数，并添加 return 返回 Promise
|
||
return this.upload({
|
||
url: options.url,
|
||
header: options.header,
|
||
timeout: options.timeout,
|
||
filePath: file.path,
|
||
//name: file.name ?? 'file',
|
||
}, null).then((response : IResponse) : IFileInfo => { // 显式指定 then 的返回类型
|
||
let { code, data } = response
|
||
if (code == 0 && data != null) {
|
||
const result = (data as UTSJSONObject).parse<IUploadInfo>()
|
||
file.fid = result?.fid ?? 0
|
||
file.name = result?.name ?? file.name
|
||
file.path = result?.url ?? file.path
|
||
}
|
||
return file // 直接返回 file，不要用 Promise.resolve
|
||
}).catch((error) : IFileInfo => {
|
||
console.log(error);
|
||
return file
|
||
})
|
||
})
|
||
return Promise.all(uploadPromises)
|
||
}
|
||
// /**
|
||
// * 带整体进度回调的并行上传
|
||
// */
|
||
// async uploadMultipleFilesWithProgress<T = any>(options : IUploadOption, files : IFileInfo[], onProgress ?: (completed : number, total : number, results : IUploadResult<T>[]) => void) : Promise<IUploadResult<T>[]> {
|
||
// const results : IUploadResult<T>[] = new Array()
|
||
// let completedCount = 0
|
||
// const uploadPromises = files.map((file) => {
|
||
// return this.upload<T>({
|
||
// url: options.url,
|
||
// header: options.header,
|
||
// timeout: options.timeout,
|
||
// filePath: file.path,
|
||
// name: file.name ?? 'file',
|
||
// formData: {
|
||
// ...(options.formData ?? {}),
|
||
// fileIndex: file.index.toString(),
|
||
// fileCount: files.length.toString()
|
||
// }
|
||
// }).then((result) => {
|
||
// results[file.index] = {
|
||
// index: file.index,
|
||
// success: true,
|
||
// data: result
|
||
// }
|
||
// completedCount++
|
||
// onProgress?.(completedCount, files.length, [...results])
|
||
// return results[file.index]
|
||
// }).catch((error) => {
|
||
// results[file.index] = {
|
||
// index: file.index,
|
||
// success: false,
|
||
// error: error
|
||
// }
|
||
// completedCount++
|
||
// onProgress?.(completedCount, files.length, [...results])
|
||
// return results[file.index]
|
||
// })
|
||
// })
|
||
// await Promise.all(uploadPromises)
|
||
// return results
|
||
// }
|
||
|
||
}
|
||
|
||
|
||
const httpApi = new SimpleHttp()
|
||
|
||
// 导出
|
||
export default httpApi
|
||
export type { IResponse, IRequestOption, INetworkInfo, IDownRespone, IUploadOption, IFileInfo }
|
||
|
||
// import http, { SimpleHttp, IResponse } from './simple-http'
|
||
|
||
// // 使用默认配置
|
||
// const api = http
|
||
|
||
// // 或者创建自定义实例
|
||
// const customApi = new SimpleHttp('https://api.yourservice.com', {
|
||
// timeout: 20000,
|
||
// debug: true,
|
||
// tokenType: 'Bearer',
|
||
// enableRefreshToken: true
|
||
// }) |