Analysieren Sie, wie Uniapp den Schnittstellendomänennamen dynamisch erhält

Konfiguration aus „@/config“ importieren
Vue von „vue“ importieren
importiere cacheData aus '@/service/cacheData.js'
const MockUtil = () => import('@/libs/mockUtil.js')
Speicher aus „@/libs/storage.js“ importieren

Klasse HttpRequest {

    /**
     * Schnittstellendaten lesen * @param Optionen Informationen anfordern * @param noMock Wenn Sie Mock-Daten als Ganzes verwenden, können Sie eine separate Schnittstelle festlegen, um echte Daten anzufordern * @param cacheId
     * @returns {*}
     */
    asynchrone Anfrageauflösung (Optionen, URL-Anpassung = '', noMock = false, Cache-ID = null) {
        let remoteIP = await config.requestRemoteIp(); // Den Domänennamen der Schnittstellenanforderung dynamisch festlegen, if (process.env.NODE_ENV === 'development' && config.isMockApi && !noMock) {
            gib dies zurück.getMockData(Optionen)
        }
        wenn (cacheId && cacheData[cacheId]) {
            gib dies zurück.testHttp(cacheData[cacheId])
        }
        returniere neues Promise((lösen, ablehnen) => {
            let baseUrl = process.env.NODE_ENV === 'Entwicklung'? config.baseUrl.dev: config.baseUrl.pro;
            Optionen.URL = Basis-URL + Optionen.URL + `${urlCustom}`;
            uni.anfrage(
                Objekt.zuweisen({
                    Erfolg: (res) => {
                        wenn (res.statusCode != '200'){
                            uni.showToast({
                                Titel: 'Serverfehler:' + res.statusCode,
                                Symbol: „keine“
                            })
                            ablehnen()
                        }
                        sonst wenn (res.data.code == 10001) {
                            Speicher.removeToken();
                            lass vue = neues Vue();
                            vue.$store.dispatch('Abmelden')
                            vue.$routeUtil.reLaunch('main');
                        }
                        
                        sonst wenn (res.data.code != 200) {
                            wenn (res.data.message) {
                                uni.showToast({
                                    Symbol: „keine“,
                                    Titel: res.data.message
                                });
                            }
                            ablehnen(res.data)
                        } anders {
                            wenn (Cache-ID) {
                                cacheData[cacheId] = res.data.data
                            }
                            auflösen(res.data.data)
                        }
                    },
                    fehlgeschlagen: err => {
                        uni.showToast({
                            Titel: 'Serverfehler',
                            Symbol: „keine“
                        })
                    }
                }, Optionen)
            );
        })
    }

    /**
     *Mock-Daten werden bei Bedarf importiert* @param-Optionen
     * @returns {*}
     */
    async getMockData(Optionen) {
        const Mock = warte auf MockUtil()
        const MockUrl = Mock.default[Optionen.URL]
        wenn (Typ von MockUrl !== 'Funktion') {
            gib dies zurück.testHttp(MockUrl)
        }
        wenn (Optionen.Methode === 'post') {
            gib dies zurück.testHttp(MockUrl(options.data, false))
        }
        gib dies zurück.testHttp(MockUrl(options.params, true))
    }
    testHttp(Daten) {
        let pro = neues Versprechen(Funktion(auflösen, ablehnen) {
            setzeTimeout(Funktion() {
                auflösen (Daten)
            }, 50)
        })
        Rückkehrprofi
    }
}
exportiere standardmäßig neue HttpRequest()

const konfiguration = {
  isMockApi: falsch,
  // Anfrage-URL: 'http://qiniu.eightyin.cn/teacherpath.json?time=' + Math.random().toString(36),
  requestUrl: 'http://qiniu.eightyin.cn/teacherpathtest.json?time=' + Math.random().toString(36),
  Basis-URL: {
     
    Entwickler: '',
    Profi: ''
  },
  img: {
    ossDomain: ''
  },
  uuid: Math.random().toString(36).substring(3, 20),
  requestRemoteIp: () => {
      console.log('Konfiguration:', Konfiguration)
      wenn (config.RemoteIpInited)
        gibt Promise.resolve() zurück;
        returniere neues Promise((lösen, ablehnen) => {
            uni.request({
                URL: config.requestUrl,
                Erfolg: (Antwort) => {
                    //zu testen// config.baseUrl.pro = response.data.data.path;
                    config.baseUrl.dev = "http://bayin5.mycwgs.com/";
                    config.img.ossDomain = response.data.data.ossDomain;
                    config.RemoteIpInited = true;
                    lösen()
                },
                fehlgeschlagen: () => {
                    config.RemoteIpInited = true;
                    lösen()
                }
            })
        });
  }
}

Standardkonfiguration exportieren