汇融云链2

This commit is contained in:
2023-02-13 18:43:39 +08:00
parent 76dca84266
commit a29788866e
331 changed files with 95753 additions and 0 deletions

View File

@@ -0,0 +1,390 @@
import request from "./request.js";
const qiniuUploader = require("./qiniuUploader");
export default class fileUpload extends request {
constructor(props) {
// 调用实现父类的构造函数
super(props);
}
//七牛云上传图片
qnImgUpload(data = {}, options = {}) {
const _this = this;
return new Promise((resolve, reject) => {
uni.chooseImage({
count: data.count || 9, //默认9
sizeType: data.sizeType || ['original', 'compressed'], //可以指定是原图还是压缩图,默认二者都有
sourceType: data.sourceType || ['album', 'camera'], //从相册选择
success: function(res) {
_this.qnFileUpload({
files: res.tempFiles,
...data
}, options).then(resolve, reject);
}
});
});
}
//七牛云上传文件命名
randomChar(l, url = "") {
const x = "0123456789qwertyuioplkjhgfdsazxcvbnm";
let tmp = "";
let time = new Date();
for (let i = 0; i < l; i++) {
tmp += x.charAt(Math.ceil(Math.random() * 100000000) % x.length);
}
return (
"file/" +
url +
time.getTime() +
tmp
);
}
//七牛云文件上传(支持多张上传)
qnFileUpload(data = {}, options = {}) {
const _this = this;
let requestInfo = {
...data,
...this.config,
...options,
header: {},
method: "FILE"
};
return new Promise((resolve, reject) => {
//请求前回调
if (_this.requestStart) {
let requestStart = _this.requestStart(requestInfo);
if (typeof requestStart == "object") {
requestInfo.load = requestStart.load;
requestInfo.files = requestStart.files;
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
reject({
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
return;
}
}
if (Array.isArray(requestInfo.files)) {
let len = requestInfo.files.length;
let imageList = new Array;
if(_this.getQnToken){
_this.getQnToken(qnRes => {
/*
*接口返回参数:
*visitPrefix:访问文件的域名
*token:七牛云上传token
*folderPath:上传的文件夹
*region: 地区 默认为SCN
*/
uploadFile(0);
function uploadFile(i) {
let fileData = {
fileIndex: i,
files: requestInfo.files,
size: requestInfo.files[i].size
};
// #ifdef H5
fileData.name = requestInfo.files[i].name;
fileData.type = requestInfo.files[i].type;
// #endif
// 交给七牛上传
qiniuUploader.upload(requestInfo.files[i].path, (res) => {
fileData.url = res.imageURL;
requestInfo.onEachUpdate && requestInfo.onEachUpdate({
url: res.imageURL,
...fileData
});
imageList.push(res.imageURL);
if (len - 1 > i) {
uploadFile(i + 1);
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "request:ok",
statusCode: 200,
data: imageList
});
resolve(imageList);
}
}, (error) => {
console.log('error: ' + error);
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, error);
reject(error)
}, {
region: qnRes.region || 'SCN', //地区
domain: qnRes.visitPrefix, // bucket 域名,下载资源时用到。
key: _this.randomChar(8, qnRes.folderPath),
uptoken: qnRes.token, // 由其他程序生成七牛 uptoken
uptokenURL: 'UpTokenURL.com/uptoken' // 上传地址
}, (res) => {
console.log(requestInfo);
requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
// console.log('上传进度', res.progress)
// console.log('已经上传的数据长度', res.totalBytesSent)
// console.log('预期需要上传的数据总长度', res.totalBytesExpectedToSend)
});
}
});
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "请添加七牛云回调方法getQnToken",
statusCode: 0
});
reject({
errMsg: "请添加七牛云回调方法getQnToken",
statusCode: 0
});
return;
}
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "files 必须是数组类型",
statusCode: 0
});
reject({
errMsg: "files 必须是数组类型",
statusCode: 0
});
};
});
}
//本地服务器图片上传
urlImgUpload(url = '', data = {}, options = {}) {
const _this = this;
return new Promise((resolve, reject) => {
uni.chooseImage({
count: data.count || 9, //默认9
sizeType: data.sizeType || ['original', 'compressed'], //可以指定是原图还是压缩图,默认二者都有
sourceType: data.sourceType || ['album', 'camera'], //从相册选择
success: function(res) {
_this.urlFileUpload(url, {
...data,
files: res.tempFiles
}, options).then(resolve, reject);
}
});
});
}
//本地服务器文件上传方法
urlFileUpload(url = '', data = {}, options = {}) {
let requestInfo = this.getDefault({
...data,
url: url,
method: "FILE"
}, options);
const _this = this;
return new Promise((resolve, reject) => {
//请求前回调
if (_this.requestStart) {
let requestStart = _this.requestStart(requestInfo);
if (typeof requestStart == "object") {
requestInfo.data = requestStart.data;
requestInfo.header = requestStart.header;
requestInfo.isPrompt = requestStart.isPrompt;
requestInfo.load = requestStart.load;
requestInfo.isFactory = requestStart.isFactory;
requestInfo.files = requestStart.files;
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
reject({
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
return;
}
}
// 本地文件上传去掉默认Content-Type
if(requestInfo.header['Content-Type']){
delete requestInfo.header['Content-Type'];
}
if (Array.isArray(requestInfo.files)) {
// #ifdef APP-PLUS || H5
let files = [];
let fileData = {
files: requestInfo.files,
name: requestInfo.name || "file"
};
requestInfo.files.forEach(item => {
files.push({
uri: item.path,
name: requestInfo.name || "file"
});
});
let config = {
url: requestInfo.url,
files: files,
header: requestInfo.header, //加入请求头
success: (response) => {
if (typeof(response.data) == "string") {
response.data = JSON.parse(response.data);
}
//是否用外部的数据处理方法
if (requestInfo.isFactory && _this.dataFactory) {
//数据处理
_this.dataFactory({
...requestInfo,
response: response,
resolve: function(data) {
requestInfo.onEachUpdate && requestInfo.onEachUpdate({
data: data,
...fileData
});
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "request:ok",
statusCode: 200,
data: data
});
resolve(data);
},
reject: function(err) {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "数据工厂返回错误",
statusCode: 0,
data: err
});
reject(err);
}
});
} else {
requestInfo.onEachUpdate && requestInfo.onEachUpdate({
data: response,
...fileData
});
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, response);
resolve(response);
}
},
fail: (err) => {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, err);
reject(err);
}
};
if (requestInfo.data) {
config.formData = requestInfo.data;
}
const uploadTask = uni.uploadFile(config);
uploadTask.onProgressUpdate(res => {
requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
});
// #endif
// #ifdef MP
const len = requestInfo.files.length - 1;
let fileList = new Array;
fileUpload(0);
function fileUpload(i) {
let fileData = {
fileIndex: i,
files: requestInfo.files,
size: requestInfo.files[i].size
};
// #ifdef H5
fileData.name = requestInfo.files[i].name;
fileData.type = requestInfo.files[i].type;
// #endif
let config = {
url: requestInfo.url,
filePath: requestInfo.files[i].path,
header: requestInfo.header, //加入请求头
name: requestInfo.name || "file",
success: (response) => {
if (typeof(response.data) == "string") {
response.data = JSON.parse(response.data);
}
//是否用外部的数据处理方法
if (requestInfo.isFactory && _this.dataFactory) {
//数据处理
_this.dataFactory({
...requestInfo,
response: response,
resolve: function(data) {
requestInfo.onEachUpdate && requestInfo.onEachUpdate({
data: data,
...fileData
});
fileList.push(data);
if (len <= i) {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "request:ok",
statusCode: 200,
data: fileList
});
resolve(fileList);
} else {
fileUpload(i + 1);
}
},
reject: function(err) {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "数据工厂返回错误",
statusCode: 0,
data: err
});
reject(err);
}
});
} else {
requestInfo.onEachUpdate && requestInfo.onEachUpdate({
data: response,
...fileData
});
fileList.push(response);
if (len <= i) {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "request:ok",
statusCode: 200,
data: fileList
});
resolve(fileList);
} else {
fileUpload(i + 1);
}
}
},
fail: (err) => {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, err);
reject(err);
}
};
if (requestInfo.data) {
config.formData = requestInfo.data;
}
const uploadTask = uni.uploadFile(config);
uploadTask.onProgressUpdate(res => {
requestInfo.onProgressUpdate && requestInfo.onProgressUpdate(Object.assign({}, fileData, res));
});
}
// #endif
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "files 必须是数组类型",
statusCode: 0
});
reject({
errMsg: "files 必须是数组类型",
statusCode: 0
})
}
});
}
}

View File

@@ -0,0 +1,7 @@
/***************纯粹的数据请求如果使用这种可以删除掉fileUpload.js******************/
// import request from "./request.js";
// export default request;
/********数据请求同时继承了文件上传(包括七牛云上传)************/
import fileUpload from "./fileUpload.js";
export default fileUpload;

View File

@@ -0,0 +1,169 @@
// created by gpake
(function () {
var config = {
qiniuRegion: '',
qiniuImageURLPrefix: '',
qiniuUploadToken: '',
qiniuUploadTokenURL: '',
qiniuUploadTokenFunction: null,
qiniuShouldUseQiniuFileName: false
}
module.exports = {
init: init,
upload: upload,
}
// 在整个程序生命周期中,只需要 init 一次即可
// 如果需要变更参数,再调用 init 即可
function init(options) {
config = {
qiniuRegion: '',
qiniuImageURLPrefix: '',
qiniuUploadToken: '',
qiniuUploadTokenURL: '',
qiniuUploadTokenFunction: null,
qiniuShouldUseQiniuFileName: false
};
updateConfigWithOptions(options);
}
function updateConfigWithOptions(options) {
if (options.region) {
config.qiniuRegion = options.region;
} else {
console.error('qiniu uploader need your bucket region');
}
if (options.uptoken) {
config.qiniuUploadToken = options.uptoken;
} else if (options.uptokenURL) {
config.qiniuUploadTokenURL = options.uptokenURL;
} else if (options.uptokenFunc) {
config.qiniuUploadTokenFunction = options.uptokenFunc;
}
if (options.domain) {
config.qiniuImageURLPrefix = options.domain;
}
config.qiniuShouldUseQiniuFileName = options.shouldUseQiniuFileName
}
function upload(filePath, success, fail, options, progress, cancelTask) {
if (null == filePath) {
console.error('qiniu uploader need filePath to upload');
return;
}
if (options) {
updateConfigWithOptions(options);
}
if (config.qiniuUploadToken) {
doUpload(filePath, success, fail, options, progress, cancelTask);
} else if (config.qiniuUploadTokenURL) {
getQiniuToken(function () {
doUpload(filePath, success, fail, options, progress, cancelTask);
});
} else if (config.qiniuUploadTokenFunction) {
config.qiniuUploadToken = config.qiniuUploadTokenFunction();
if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
console.error('qiniu UploadTokenFunction result is null, please check the return value');
return
}
doUpload(filePath, success, fail, options, progress, cancelTask);
} else {
console.error('qiniu uploader need one of [uptoken, uptokenURL, uptokenFunc]');
return;
}
}
function doUpload(filePath, success, fail, options, progress, cancelTask) {
if (null == config.qiniuUploadToken && config.qiniuUploadToken.length > 0) {
console.error('qiniu UploadToken is null, please check the init config or networking');
return
}
var url = uploadURLFromRegionCode(config.qiniuRegion);
var fileName = filePath.split('//')[1];
if (options && options.key) {
fileName = options.key;
}
var formData = {
'token': config.qiniuUploadToken
};
if (!config.qiniuShouldUseQiniuFileName) {
formData['key'] = fileName
}
var uploadTask = wx.uploadFile({
url: url,
filePath: filePath,
name: 'file',
formData: formData,
success: function (res) {
var dataString = res.data
if (res.data.hasOwnProperty('type') && res.data.type === 'Buffer') {
dataString = String.fromCharCode.apply(null, res.data.data)
}
try {
var dataObject = JSON.parse(dataString);
//do something
var imageUrl = config.qiniuImageURLPrefix + '/' + dataObject.key;
dataObject.imageURL = imageUrl;
if (success) {
success(dataObject);
}
} catch (e) {
console.log('parse JSON failed, origin String is: ' + dataString)
if (fail) {
fail(e);
}
}
},
fail: function (error) {
console.error(error);
if (fail) {
fail(error);
}
}
})
uploadTask.onProgressUpdate((res) => {
progress && progress(res)
})
cancelTask && cancelTask(() => {
uploadTask.abort()
})
}
function getQiniuToken(callback) {
wx.request({
url: config.qiniuUploadTokenURL,
success: function (res) {
var token = res.data.uptoken;
if (token && token.length > 0) {
config.qiniuUploadToken = token;
if (callback) {
callback();
}
} else {
console.error('qiniuUploader cannot get your token, please check the uptokenURL or server')
}
},
fail: function (error) {
console.error('qiniu UploadToken is null, please check the init config or networking: ' + error);
}
})
}
function uploadURLFromRegionCode(code) {
var uploadURL = null;
switch (code) {
case 'ECN': uploadURL = 'https://up.qbox.me'; break;
case 'NCN': uploadURL = 'https://up-z1.qbox.me'; break;
case 'SCN': uploadURL = 'https://up-z2.qbox.me'; break;
case 'NA': uploadURL = 'https://up-na0.qbox.me'; break;
case 'ASG': uploadURL = 'https://up-as0.qbox.me'; break;
default: console.error('please make the region is with one of [ECN, SCN, NCN, NA, ASG]');
}
return uploadURL;
}
})();

View File

@@ -0,0 +1,225 @@
export default class request {
constructor(options) {
//请求公共地址
this.baseUrl = options.baseUrl || "";
//公共文件上传请求地址
this.fileUrl = options.fileUrl || "";
//默认请求头
this.header = options.header || {};
//默认配置
this.config = {
isPrompt: options.isPrompt === false ? false : true,
load: options.load === false ? false : true,
isFactory: options.isFactory === false ? false : true,
loadMore: options.loadMore === false ? false : true
};
}
// 获取默认信息
getDefault(data, options = {}) {
//判断url是不是链接
let urlType = /^([hH][tT]{2}[pP]:\/\/|[hH][tT]{2}[pP][sS]:\/\/)(([A-Za-z0-9-~]+).)+([A-Za-z0-9-~/])+$/.test(data.url);
let config = Object.assign({}, this.config, options, data);
if (data.method == "FILE") {
config.url = urlType ? data.url : this.fileUrl + data.url;
} else {
config.url = urlType ? data.url : this.baseUrl + data.url;
}
//请求头
if (options.header) {
config.header = Object.assign({}, this.header, options.header);
} else if (data.header) {
config.header = Object.assign({}, this.header, data.header);
} else {
config.header = this.header;
}
return config;
}
//post请求
post(url = '', data = {}, options = {}) {
return this.request({
method: "POST",
data: data,
url: url,
...options
});
}
//get请求
get(url = '', data = {}, options = {}) {
return this.request({
method: "GET",
data: data,
url: url,
...options
});
}
//put请求
put(url = '', data = {}, options = {}) {
return this.request({
method: "PUT",
data: data,
url: url,
...options
});
}
//delete请求
delete(url = '', data = {}, options = {}) {
return this.request({
method: "DELETE",
data: data,
url: url,
...options
});
}
//接口请求方法
request(data) {
return new Promise((resolve, reject) => {
if (!data.url) {
console.log("request缺失数据url");
reject({
errMsg: "缺失数据url",
statusCode: 0
});
return;
}
let requestInfo = this.getDefault(data);
//请求前回调
if (this.requestStart) {
let requestStart = this.requestStart(requestInfo);
if (typeof requestStart == "object") {
requestInfo.data = requestStart.data;
requestInfo.header = requestStart.header;
requestInfo.isPrompt = requestStart.isPrompt;
requestInfo.load = requestStart.load;
requestInfo.isFactory = requestStart.isFactory;
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
reject({
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
return;
}
}
let requestData = {
url: requestInfo.url,
header: requestInfo.header, //加入请求头
success: (res) => {
//请求完成回调
this.requestEnd && this.requestEnd(requestInfo, res);
//是否用外部的数据处理方法
if (requestInfo.isFactory && this.dataFactory) {
//数据处理
this.dataFactory({
...requestInfo,
response: res,
resolve: resolve,
reject: reject
});
} else {
resolve(res);
}
},
fail: (err) => {
console.log("err");
//请求完成回调
this.requestEnd && this.requestEnd(requestInfo, err);
reject(err);
}
};
//请求类型
if (requestInfo.method) {
requestData.method = requestInfo.method;
}
if (requestInfo.data) {
requestData.data = requestInfo.data;
}
// #ifdef MP-WEIXIN || MP-ALIPAY
if (requestInfo.timeout) {
requestData.timeout = requestInfo.timeout;
}
// #endif
if (requestInfo.dataType) {
requestData.dataType = requestInfo.dataType;
}
// #ifndef APP-PLUS || MP-ALIPAY
if (requestInfo.responseType) {
requestData.responseType = requestInfo.responseType;
}
// #endif
// #ifdef H5
if (requestInfo.withCredentials) {
requestData.withCredentials = requestInfo.withCredentials;
}
// #endif
uni.request(requestData);
});
}
//jsonp请求(只限于H5使用)
jsonp(url = '', data = {}, options = {}) {
let requestInfo = this.getDefault({
method: "JSONP",
data: data,
url: url,
}, options);
let dataStr = '';
Object.keys(data).forEach(key => {
dataStr += key + '=' + data[key] + '&';
});
//匹配最后一个&并去除
if (dataStr !== '') {
dataStr = dataStr.substr(0, dataStr.lastIndexOf('&'));
}
requestInfo.url = requestInfo.url + '?' + dataStr;
const _this = this;
return new Promise((resolve, reject) => {
let callbackName = "callback" + Math.ceil(Math.random() * 1000000);
if (_this.requestStart) {
requestInfo.data = data;
let requestStart = _this.requestStart(requestInfo);
if (typeof requestStart == "object") {
requestInfo.data = requestStart.data;
requestInfo.header = requestStart.header;
requestInfo.isPrompt = requestStart.isPrompt;
requestInfo.load = requestStart.load;
requestInfo.isFactory = requestStart.isFactory;
} else {
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
reject({
errMsg: "请求开始拦截器未通过",
statusCode: 0
});
return;
}
}
// #ifdef H5
window[callbackName] = function(data) {
resolve(data);
}
let script = document.createElement("script");
script.src = requestInfo.url + "&callback=" + callbackName;
document.head.appendChild(script);
// 及时删除防止加载过多的JS
document.head.removeChild(script);
// #endif
//请求完成回调
_this.requestEnd && _this.requestEnd(requestInfo, {
errMsg: "request:ok",
statusCode: 200
});
});
}
}

View File

@@ -0,0 +1,229 @@
# request请求、配置简单、批量上传图片、超强适应性很方便的支持多域名请求
1. 配置简单、源码清晰注释多、适用于一项目多域名请求、第三方请求、七牛云图片上传、本地服务器图片上传等等
2. 支持请求`get``post``put``delete`
3. 自动显示请求加载动画(可单个接口关闭)
4. 全局`api`数据处理函数,只回调请求正确的数据(可单个接口关闭)
5. 未登录或登录失效自动拦截并调用登录方法(可单个接口关闭)
6. 全局自动提示接口抛出的错误信息(可单个接口关闭)
7. 支持 Promise
8. 支持拦截器
9. 支持七牛云文件(图片)批量上传
10. 支持本地服务器文件(图片)批量上传
11. 支持上传文件拦截过滤
12. 支持上传文件进度监听
13. 支持上传文件单张成功回调
### QQ交流群(学习干货多多) 607391225
![QQ交流群](http://qn.kemean.cn//upload/202004/14/15868301778472k7oubi6.png)
### 常见问题
1.接口请求成功了没有返回数据或者数据是走的catch回调
答:`requestConfig.js` 请求配置文件里面,有一个`$http.dataFactory`方法,里面写的只是参考示例,`此方法需要开发者根据各自的接口返回类型修改`
2.官方的方法有数据,本插件方法请求报错跨域问题
答:`requestConfig.js` 请求配置文件里面,`header`请求头设置的`content-type`请求类型需求和后台保持一致
3.登录后用户`token`怎么设置?
答:`requestConfig.js` 请求配置文件里面,`$http.requestStart`请求开始拦截器里面设置
4.怎么判断上传的文件(图片)太大?怎么过滤掉太大的文件(图片)?
答:`requestConfig.js` 请求配置文件里面,`$http.requestStart`请求开始拦截器里面设置
### 本次更新注意事项
1. 所有的headers都改成了header和官方统一
2. 七牛云的获取token等信息提取到了`requestConfig.js`文件,参考如下
```
// 添加获取七牛云token的方法
$http.getQnToken = function(callback){
//该地址需要开发者自行配置(每个后台的接口风格都不一样)
$http.get("api/kemean/aid/qn_upload").then(data => {
/*
*接口返回参数:
*visitPrefix:访问文件的域名
*token:七牛云上传token
*folderPath:上传的文件夹
*/
callback({
visitPrefix: data.visitPrefix,
token: data.token,
folderPath: data.folderPath
});
});
}
```
### 文件说明
1. `request => request.js` 请求方法的源码文件
2. `request => fileUpload.js` 七牛云上传和服务器上传的源码文件
3. `request => index.js` 输出方法的文件
4. `request => qiniuUploader.js` 七牛云官方上传文件
5. `requestConfig.js` 请求配置文件(具体看代码)
### 在main.js引入并挂在Vue上
```
import $http from '@/zhouWei-request/requestConfig';
Vue.prototype.$http = $http;
```
### 通用请求方法此方法不支持文件上传和JSONP
```
this.$http.request({
url: 'aid/region',
method: "GET", // POST、GET、PUT、DELETE具体说明查看官方文档
data: {pid:0},
timeout: 30000, // 默认 30000 说明:超时时间,单位 ms具体说明查看官方文档
dataType: "json", // 默认 json 说明:如果设为 json会尝试对返回的数据做一次 JSON.parse具体说明查看官方文档
responseType: "text", // 默认 text 说明设置响应的数据类型。合法值text、arraybuffer具体说明查看官方文档
withCredentials: false, // 默认 false 说明跨域请求时是否携带凭证cookies具体说明查看官方文档
isPrompt: true,//(默认 true 说明:本接口抛出的错误是否提示)
load: true,//(默认 true 说明:本接口是否提示加载动画)
header: { //默认 无 说明:请求头
'Content-Type': 'application/json'
},
isFactory: true, //(默认 true 说明本接口是否调用公共的数据处理方法设置false后isPrompt参数将失去作用
}).then(function (response) {
//这里只会在接口是成功状态返回
}).catch(function (error) {
//这里只会在接口是失败状态返回,不需要去处理错误提示
console.log(error);
});
```
### get请求 正常写法
```
this.$http.get('aid/region',{pid:0}).
then(function (response) {
//这里只会在接口是成功状态返回
}).catch(function (error) {
//这里只会在接口是失败状态返回,不需要去处理错误提示
console.log(error);
});
```
### post请求 async写法
```
async request(){
let data = await this.$http.post('aid/region',{pid:0});
console.log(data);
}
```
### 其他功能配置项
```
let data = await this.$http.post(
'http://www.aaa.com/aid/region', //可以直接放链接(将不启用全局定义域名)
{
pid:0
},
{
isPrompt: true,//(默认 true 说明:本接口抛出的错误是否提示)
load: true,//(默认 true 说明:本接口是否提示加载动画)
header: { //默认 无 说明:请求头
'Content-Type': 'application/json'
},
isFactory: true //(默认 true 说明本接口是否调用公共的数据处理方法设置false后isPrompt参数将失去作用
}
);
```
### 本地服务器图片上传(支持多张上传)
```
this.$http.urlImgUpload('flie/upload',{
name:"后台接受文件key名称", //默认 file
count:"最大选择数",//默认 9
sizeType:"选择压缩图原图,默认两个都选",//默认 ['original', 'compressed']
sourceType:"选择相机拍照或相册上传 默认两个都选",//默认 ['album','camera']
data:"而外参数" //可不填,
onEachUpdate: res => {
console.log("单张上传成功返回:",res);
},
onProgressUpdate: res => {
console.log("上传进度返回:",res);
}
},{
isPrompt: true,//(默认 true 说明:本接口抛出的错误是否提示)
load: true,//(默认 true 说明:本接口是否提示加载动画)
header: { //默认 无 说明:请求头
'Content-Type': 'application/json'
},
isFactory: true, //(默认 true 说明本接口是否调用公共的数据处理方法设置false后isPrompt参数奖失去作用
maxSize: 300000 //(默认 无 说明:上传的文件最大字节数限制,默认不限制)
}).then(res => {
console.log("全部上传完返回结果:",res);
});
```
### 本地服务器文件上传(支持多张上传)
```
this.$http.urlFileUpload("flie/upload",{
files:[], // 必填 临时文件路径
data:"向服务器传递的参数", //可不填
name:"后台接受文件key名称", //默认 file
onEachUpdate: res => {
console.log("单张上传成功返回:",res);
},
onProgressUpdate: res => {
console.log("上传进度返回:",res);
}
},
{
isPrompt: true,//(默认 true 说明:本接口抛出的错误是否提示)
load: true,//(默认 true 说明:本接口是否提示加载动画)
header: { //默认 无 说明:请求头
'Content-Type': 'application/json'
},
isFactory: true, //(默认 true 说明本接口是否调用公共的数据处理方法设置false后isPrompt参数奖失去作用
maxSize: 300000 //(默认 无 说明:上传的文件最大字节数限制,默认不限制)
}).then(res => {
console.log("全部上传完返回结果:",res);
});
```
### 七牛云图片上传(支持多张上传)
```
this.$http.qnImgUpload({
count:"最大选择数", // 默认 9
sizeType:"选择压缩图原图,默认两个都选", // 默认 ['original', 'compressed']
sourceType:"选择相机拍照或相册上传 默认两个都选", // 默认 ['album','camera']
onEachUpdate: res => {
console.log("单张上传成功返回:",res);
},
onProgressUpdate: res => {
console.log("上传进度返回:",res);
}
},
{
load: true, //(默认 true 说明:本接口是否提示加载动画)
maxSize: 300000 //(默认 无 说明:上传的文件最大字节数限制,默认不限制)
}).then(res => {
console.log("全部上传完返回结果:",res);
});
```
### 七牛云文件上传(支持多张上传)
```
this.$http.qnFileUpload(
{
files:[], // 必填 临时文件路径
onEachUpdate: res => {
console.log("单张上传成功返回:",res);
},
onProgressUpdate: res => {
console.log("上传进度返回:",res);
}
},
{
load: true, //(默认 true 说明:本接口是否提示加载动画)
maxSize: 300000 //(默认 无 说明:上传的文件最大字节数限制,默认不限制)
}).then(res => {
console.log("全部上传完返回结果:",res);
});
```
### jsonp 跨域请求只支持H5
```
let data = await this.$http.jsonp('http://www.aaa.com/aid/region',{pid:0});
```