uniapp 底层

app/src/utils/auth.ts

@@ -0,0 +1,6 @@
+import { TOKEN_KEY } from '@/enums/cacheEnums'
+import cache from './cache'
+
+export function getToken() {
+    return cache.get(TOKEN_KEY)
+}

app/src/utils/cache.ts

@@ -0,0 +1,50 @@
+const cache = {
+    key: 'app_',
+    //设置缓存(expire为缓存时效)
+    set(key: string, value: any, expire?: string) {
+        key = this.getKey(key)
+        let data: any = {
+            expire: expire ? this.time() + expire : '',
+            value
+        }
+
+        if (typeof data === 'object') {
+            data = JSON.stringify(data)
+        }
+        try {
+            window.localStorage.setItem(key, data)
+        } catch (e) {
+            return null
+        }
+    },
+    get(key: string) {
+        key = this.getKey(key)
+        try {
+            const data = window.localStorage.getItem(key)
+            if (!data) {
+                return null
+            }
+            const { value, expire } = JSON.parse(data)
+            if (expire && expire < this.time()) {
+                window.localStorage.removeItem(key)
+                return null
+            }
+            return value
+        } catch (e) {
+            return null
+        }
+    },
+    //获取当前时间
+    time() {
+        return Math.round(new Date().getTime() / 1000)
+    },
+    remove(key: string) {
+        key = this.getKey(key)
+        window.localStorage.removeItem(key)
+    },
+    getKey(key: string) {
+        return this.key + key
+    }
+}
+
+export default cache

app/src/utils/request/cancel.ts

@@ -0,0 +1,28 @@
+import { RequestTask } from './type'
+
+const cancelerMap = new Map<string, RequestTask>()
+
+export class RequestCancel {
+    private static instance?: RequestCancel
+
+    static createInstance() {
+        return this.instance ?? (this.instance = new RequestCancel())
+    }
+    add(url: string, requestTask: RequestTask) {
+        this.remove(url)
+        if (!cancelerMap.has(url)) {
+            cancelerMap.set(url, requestTask)
+        }
+    }
+    remove(url: string) {
+        if (cancelerMap.has(url)) {
+            const requestTask = cancelerMap.get(url)
+            requestTask && requestTask.abort()
+            cancelerMap.delete(url)
+        }
+    }
+}
+
+const requestCancel = RequestCancel.createInstance()
+
+export default requestCancel

app/src/utils/request/http.ts

@@ -0,0 +1,70 @@
+import { merge } from 'lodash-es'
+import { isFunction } from '@vue/shared'
+import { HttpRequestOptions, RequestConfig, RequestOptions } from './type'
+import { RequestMethodsEnum } from '@/enums/requestEnums'
+import requestCancel from './cancel'
+
+export default class HttpRequest {
+    private readonly options: HttpRequestOptions
+    constructor(options: HttpRequestOptions) {
+        this.options = options
+    }
+
+    /**
+     * @description get请求
+     */
+    get<T = any>(options: RequestOptions, config?: Partial<RequestConfig>): Promise<T> {
+        return this.request({ ...options, method: RequestMethodsEnum.GET }, config)
+    }
+
+    /**
+     * @description post请求
+     */
+    post<T = any>(options: RequestOptions, config?: Partial<RequestConfig>): Promise<T> {
+        return this.request({ ...options, method: RequestMethodsEnum.POST }, config)
+    }
+    /**
+     * @description 请求函数
+     */
+    async request(options: RequestOptions, config?: Partial<RequestConfig>): Promise<any> {
+        let mergeOptions: RequestOptions = merge({}, this.options.requestOptions, options)
+        const mergeConfig: RequestConfig = merge({}, this.options, config)
+        const { requestInterceptorsHook, responseInterceptorsHook, responseInterceptorsCatchHook } =
+            mergeConfig.requestHooks || {}
+        if (requestInterceptorsHook && isFunction(requestInterceptorsHook)) {
+            mergeOptions = requestInterceptorsHook(options, mergeConfig)
+        }
+        return new Promise((resolve, reject) => {
+            const requestTask = uni.request({
+                ...mergeOptions,
+                success(response) {
+                    if (responseInterceptorsHook && isFunction(responseInterceptorsHook)) {
+                        try {
+                            response = responseInterceptorsHook(response, mergeConfig)
+                            resolve(response)
+                        } catch (error) {
+                            reject(error)
+                        }
+                        return
+                    }
+                    resolve(response)
+                },
+                fail(err) {
+                    if (
+                        responseInterceptorsCatchHook &&
+                        isFunction(responseInterceptorsCatchHook)
+                    ) {
+                        reject(responseInterceptorsCatchHook(err, mergeConfig))
+                        return
+                    }
+                    reject(err)
+                },
+                complete() {
+                    requestCancel.remove(options.url)
+                }
+            })
+            const { ignoreCancel } = mergeConfig
+            !ignoreCancel && requestCancel.add(options.url, requestTask)
+        })
+    }
+}

app/src/utils/request/index.ts

@@ -0,0 +1,87 @@
+import HttpRequest from './http'
+import { merge } from 'lodash-es'
+import { HttpRequestOptions, RequestHooks } from './type'
+import { getToken } from '../auth'
+import { RequestCodeEnum } from '@/enums/requestEnums'
+
+const requestHooks: RequestHooks = {
+    requestInterceptorsHook(options, config) {
+        const { urlPrefix, baseUrl, withToken } = config
+        options.header = options.header ?? {}
+        if (urlPrefix) {
+            options.url = `${urlPrefix}${options.url}`
+        }
+        if (baseUrl) {
+            options.url = `${baseUrl}${options.url}`
+        }
+        // 添加token
+        if (withToken) {
+            const token = getToken()
+            options.header.token = token
+        }
+        return options
+    },
+    responseInterceptorsHook(response, config) {
+        const { isTransformResponse, isReturnDefaultResponse } = config
+
+        //返回默认响应，当需要获取响应头及其他数据时可使用
+        if (isReturnDefaultResponse) {
+            return response
+        }
+        // 是否需要对数据进行处理
+        if (!isTransformResponse) {
+            return response.data
+        }
+        const { code, data, msg } = response.data as any
+        switch (code) {
+            case RequestCodeEnum.SUCCESS:
+                return data
+
+            case RequestCodeEnum.PARAMS_TYPE_ERROR:
+            case RequestCodeEnum.PARAMS_VALID_ERROR:
+            case RequestCodeEnum.REQUEST_METHOD_ERROR:
+            case RequestCodeEnum.ASSERT_ARGUMENT_ERROR:
+            case RequestCodeEnum.ASSERT_MYBATIS_ERROR:
+            case RequestCodeEnum.LOGIN_ACCOUNT_ERROR:
+            case RequestCodeEnum.LOGIN_DISABLE_ERROR:
+            case RequestCodeEnum.NO_PERMISSTION:
+            case RequestCodeEnum.FAILED:
+            case RequestCodeEnum.SYSTEM_ERROR:
+                return Promise.reject(data)
+
+            case RequestCodeEnum.TOKEN_INVALID:
+            case RequestCodeEnum.TOKEN_EMPTY:
+                return Promise.reject()
+
+            default:
+                return data
+        }
+    }
+}
+
+const defaultOptions: HttpRequestOptions = {
+    requestOptions: {
+        timeout: 10 * 1000
+    },
+    baseUrl: 'https://likeadmin-java.yixiangonline.com',
+    //是否返回默认的响应
+    isReturnDefaultResponse: false,
+    // 需要对返回数据进行处理
+    isTransformResponse: true,
+    // 接口拼接地址
+    urlPrefix: '/api',
+    // 忽略重复请求
+    ignoreCancel: false,
+    // 是否携带token
+    withToken: true,
+    requestHooks: requestHooks
+}
+
+function createRequest(opt?: HttpRequestOptions) {
+    return new HttpRequest(
+        // 深度合并
+        merge(defaultOptions, opt || {})
+    )
+}
+const request = createRequest()
+export default request

app/src/utils/request/type.d.ts

@@ -0,0 +1,23 @@
+export type RequestOptions = UniApp.RequestOptions
+export type ResponseResult = UniApp.RequestSuccessCallbackResult
+export type ResponseError = UniApp.GeneralCallbackResult
+export type RequestTask = UniApp.RequestTask
+export interface HttpRequestOptions extends RequestConfig {
+    requestOptions: Partial<RequestOptions>
+}
+
+export interface RequestConfig {
+    baseUrl: string
+    requestHooks: RequestHooks
+    isReturnDefaultResponse: boolean
+    isTransformResponse: boolean
+    urlPrefix: string
+    ignoreCancel: boolean
+    withToken: boolean
+}
+
+export interface RequestHooks {
+    requestInterceptorsHook?(options: RequestOptions, config: RequestConfig): RequestOptions
+    responseInterceptorsHook?(response: ResponseResult, config: RequestConfig): any
+    responseInterceptorsCatchHook?(error: ResponseError, config: RequestConfig): any
+}