axios详解以及完整封装方法

"""
一、axios是什么

Axios 是一个基于 promise 网络请求库，作用于node.js 和浏览器中。 它是 isomorphic 的(即同一套代码可以运行在浏览器和node.js中)。在服务端它使用原生 node.js http 模块, 而在客户端 (浏览端) 则使用 XMLHttpRequests。
axios有以下特性：

• 从浏览器创建 XMLHttpRequests
  
• 从 node.js 创建 http 请求
  
• 支持 Promise API
  
• 拦截请求和响应
  
• 转换请求和响应数据
  
• 取消请求
  
• 自动转换JSON数据
  
• 客户端支持防御XSRF
  

axios可以请求的方法：

• get：获取数据，请求指定的信息，返回实体对象
  
• post：向指定资源提交数据（例如表单提交或文件上传）
  
• put：更新数据，从客户端向服务器传送的数据取代指定的文档的内容
  
• patch：更新数据，是对put方法的补充，用来对已知资源进行局部更新
  
• delete：请求服务器删除指定的数据
  
• head：获取报文首部
  

请求方法别名
为了方便起见，axios为所有支持的请求方法提供了别名:

• axios(config)
  
• axios.request(config)
  
• axios.get(url [,config])
  
• axios.post(url [,data [,config]])
  
• axios.put(url [,data [,config]])
  
• axios.delete(url [,config])
  
• axios.patch(url [,data [,config]])
  
• axios.head(url [,config])
  

二.axios实例及配置方法

1.创建axios实例
axios.create([config])
可以同时创建多个axios实例。
示例代码
"""

1. const instance = axios.create({
2. baseURL: 'https://some-domain.com/api/',
3. timeout: 1000,
4. headers: {'X-Custom-Header': 'foobar'}
5. });

复制代码

"""
实例方法
以下是可用的实例方法。指定的配置将与实例的配置合并。

• axios#request(config)
  
• axios#get(url[, config])
  
• axios#delete(url[, config])
  
• axios#head(url[, config])
  
• axios#options(url[, config])
  
• axios#post(url[, data[, config]])
  
• axios#put(url[, data[, config]])
  
• axios#patch(url[, data[, config]])
  
• axios#getUri([config])
  

2.配置方法
配置对象常用的配置项：
这些是创建请求时可以用的配置选项。只有 url 是必需的。如果没有指定 method，请求将默认使用 GET 方法。更多配置项请查看官方文档
"""

1. {
2.   // 路径url
3.   url: '/user',
5.   // 请求方法，默认get
6.   method: 'get',
8.   //基础url，最终请求的url是 baseURL+url拼接，所以再全局设置默认，可以使得发送请求时的url变得简洁
9.   baseURL: 'https://some-domain.com/api/',
11.   //设置请求头
12.   headers: {'X-Requested-With': 'XMLHttpRequest'},
14.   //设置请求url的query参数，可以使得url简洁。
15.   //比如url是https://some-domain.com/api/user  然后params如下设置，那么最终的url是：
16.   //https://some-domain.com/api/user?ID=12345&name=Jack
17.   params: {
18.         ID: 12345,
19.         name:"Jack"
20.   },
22. //设置请求体
23.   data: {
24.         firstName: 'Fred'
25.   },
27.   //设置请求的另外一种格式，不过这个是直接设置字符串的
28.   data: 'Country=Brasil&City=Belo Horizonte',
30. //请求超时，单位毫秒，默认0，不超时。
31.   timeout: 1000,
33.   //响应数据类型，默认json
34.   responseType: 'json',
36.   //响应数据的编码规则，默认utf-8
37.   responseEncoding: 'utf8',
39.         //响应体的最大长度
40.   maxContentLength: 2000,
42.   // 请求体的最大长度
43.   maxBodyLength: 2000,
45.   //设置响应状态码为多少时是成功，调用resolve，否则调用reject失败
46.   //默认是大于等于200，小于300
47.   validateStatus: function (status) {
48.         return status >= 200 && status < 300;
49.   },

复制代码

"""
默认配置
可以设置全局默认配置，是为了避免多种重复配置在不同请求中重复，比如baseURL、timeout等，这里设置baseURL。
全局 axios 默认值
"""

1. axios.defaults.baseURL = 'https://api.example.com';
2. axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
3. axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';

复制代码

"""
自定义实例默认值
"""

1. // 创建实例时配置默认值
2. const instance = axios.create({
3.   baseURL: 'https://api.example.com'
4. });
6. // 创建实例后修改默认值
7. instance.defaults.headers.common['Authorization'] = AUTH_TOKEN;

复制代码

""""
配置的优先级
配置将会按优先级进行合并。它的顺序是：在 lib/defaults.js 中找到的库默认值，然后是实例的 defaults 属性，最后是请求的 config 参数。后面的优先级要高于前面的。
三、拦截器

在请求或响应被 then 或 catch 处理前拦截它们，自定义的axios实例也可添加拦截器，如：
"""

1. const instance = axios.create();
2. instance.interceptors.request.use(function () {/*...*/});

复制代码

"""
请求拦截器
示例代码：
"""

1. // 添加请求拦截器
2. axios.interceptors.request.use(function (config) {
3.         // 在发送请求之前做些什么
4.         return config;
5.   }, function (error) {
6.         // 对请求错误做些什么
7.         return Promise.reject(error);
8.   });

复制代码

"""
响应拦截器
示例代码：
"""

1. // 添加响应拦截器
2. axios.interceptors.response.use(function (response) {
3.         // 2xx 范围内的状态码都会触发该函数。
4.         // 对响应数据做点什么
5.         return response;
6.   }, function (error) {
7.         // 超出 2xx 范围的状态码都会触发该函数。
8.         // 对响应错误做点什么
9.         return Promise.reject(error);
10.   });

复制代码

"""
取消拦截器
示例代码：
"""

1. const myInterceptor = axios.interceptors.request.use(function () {/*...*/});
2. axios.interceptors.request.eject(myInterceptor);

复制代码

"""
四、取消请求

注意：从 v0.22.0 开始，Axios 支持以 fetch API 方式——  AbortController 取消请求，CancelToken API被弃用
这里我们两种方法都介绍一下，使用过程中能用 AbortController 就尽量别用 CancelToken
AbortController
"""

1. const controller = new AbortController();
3. axios.get('/foo/bar', {
4.    signal: controller.signal
5. }).then(function(response) {
6.    //...
7. });
8. // 取消请求
9. controller.abort()

复制代码

"""
CancelToken
"""

1. let source = axios.CancelToken.source();
3. axios.get('/users/12345',{
4.                                 cancelToken: source.token
5.                         }).then(res=>{
6.                                 console.log(res)
7.                         }).catch(err=>{
8.                                 //取消请求后会执行该方法
9.                                 console.log(err)
10.                         })
12. //取消请求，参数可选，该参数信息会发送到请求的catch中
13. source.cancel('取消后的信息');

复制代码

"""
也可以通过传递一个 executor 函数到 CancelToken 的构造函数来创建一个 cancel token：
"""

1. const CancelToken = axios.CancelToken;
2. let cancel;
4. axios.get('/user/12345', {
5.   cancelToken: new CancelToken(function executor(c) {
6.         // executor 函数接收一个 cancel 函数作为参数
7.         cancel = c;
8.   })
9. });
11. // 取消请求
12. cancel();

复制代码

"""
注意: 可以使用同一个 cancel token 或 signal 取消多个请求
五、axios封装

先设计我们想要这个通用请求能达到什么样的效果：

• 优化配置，设置默认配置项（responseType、跨域携带cookie、token、超时设置）
  
• 统一设置请求头
  
• 根据环境设置 baseURL
  
• 通过 Axios 方法直接发起请求
  
• 添加请求拦截器
  
• 添加响应拦截器
  
• 导出 Promise 对象
  
• 封装 Post 方法，精简 post 请求方式
  
• 封装 Get 方法，精简 get 请求方式
  
• 请求成功，配置业务状态码
  
• 全局的loading配置
  

1. 一、axios的封装
2. 在vue项目中，和后台交互获取数据这块，我们通常使用的是axios库，它是基于promise的http库，可运行在浏览器端和node.js中。他有很多优秀的特性，例如拦截请求和响应、取消请求、转换json、客户端防御XSRF等。所以我们的尤大大也是果断放弃了对其官方库vue-resource的维护，直接推荐我们使用axios库。如果还对axios不了解的，可以移步axios文档。
4. 安装
5. npm install axios; // 安装axios
6. 引入
7. 一般我会在项目的src目录中，新建一个request文件夹，然后在里面新建一个http.js和一个api.js文件。http.js文件用来封装我们的axios，api.js用来统一管理我们的接口。
9. // 在http.js中引入axios
10. import axios from 'axios'; // 引入axios
11. import QS from 'qs'; // 引入qs模块，用来序列化post类型的数据，后面会提到
12. // vant的toast提示框组件，大家可根据自己的ui组件更改。
13. import { Toast } from 'vant';
14. 环境的切换
15. 我们的项目环境可能有开发环境、测试环境和生产环境。我们通过node的环境变量来匹配我们的默认的接口url前缀。axios.defaults.baseURL可以设置axios的默认请求地址就不多说了。
17. // 环境的切换
18. if (process.env.NODE_ENV == 'development') {   
19.         axios.defaults.baseURL = 'https://www.baidu.com';}
20. else if (process.env.NODE_ENV == 'debug') {   
21.         axios.defaults.baseURL = 'https://www.ceshi.com';
22. }
23. else if (process.env.NODE_ENV == 'production') {   
24.         axios.defaults.baseURL = 'https://www.production.com';
25. }
26. 设置请求超时
27. 通过axios.defaults.timeout设置默认的请求超时时间。例如超过了10s，就会告知用户当前请求超时，请刷新等。
29. axios.defaults.timeout = 10000;
30. post请求头的设置
31. post请求的时候，我们需要加上一个请求头，所以可以在这里进行一个默认的设置，即设置post的请求头为application/x-www-form-urlencoded;charset=UTF-8
33. axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
34. 请求拦截
35. 我们在发送请求前可以进行一个请求的拦截，为什么要拦截呢，我们拦截请求是用来做什么的呢？比如，有些请求是需要用户登录之后才能访问的，或者post请求的时候，我们需要序列化我们提交的数据。这时候，我们可以在请求被发送之前进行一个拦截，从而进行我们想要的操作。
37. 请求拦截
38. // 先导入vuex,因为我们要使用到里面的状态对象
39. // vuex的路径根据自己的路径去写
40. import store from '@/store/index';
42. // 请求拦截器axios.interceptors.request.use(   
43.         config => {        
44.                 // 每次发送请求之前判断vuex中是否存在token        
45.                 // 如果存在，则统一在http请求的header都加上token，这样后台根据token判断你的登录情况
46.                 // 即使本地存在token，也有可能token是过期的，所以在响应拦截器中要对返回状态进行判断
47.                 const token = store.state.token;        
48.                 token && (config.headers.Authorization = token);        
49.                 return config;   
50.         },   
51.         error => {        
52.                 return Promise.error(error);   
53. })
54. 这里说一下token，一般是在登录完成之后，将用户的token通过localStorage或者cookie存在本地，然后用户每次在进入页面的时候（即在main.js中），会首先从本地存储中读取token，如果token存在说明用户已经登陆过，则更新vuex中的token状态。然后，在每次请求接口的时候，都会在请求的header中携带token，后台人员就可以根据你携带的token来判断你的登录是否过期，如果没有携带，则说明没有登录过。这时候或许有些小伙伴会有疑问了，就是每个请求都携带token，那么要是一个页面不需要用户登录就可以访问的怎么办呢？其实，你前端的请求可以携带token，但是后台可以选择不接收啊！
56. 响应的拦截
57. // 响应拦截器
58. axios.interceptors.response.use(   
59.         response => {   
60.                 // 如果返回的状态码为200，说明接口请求成功，可以正常拿到数据     
61.                 // 否则的话抛出错误
62.                 if (response.status === 200) {            
63.                         return Promise.resolve(response);        
64.                 } else {            
65.                         return Promise.reject(response);        
66.                 }   
67.         },   
68.         // 服务器状态码不是2开头的的情况
69.         // 这里可以跟你们的后台开发人员协商好统一的错误状态码   
70.         // 然后根据返回的状态码进行一些操作，例如登录过期提示，错误提示等等
71.         // 下面列举几个常见的操作，其他需求可自行扩展
72.         error => {            
73.                 if (error.response.status) {            
74.                         switch (error.response.status) {               
75.                                 // 401: 未登录
76.                                 // 未登录则跳转登录页面，并携带当前页面的路径
77.                                 // 在登录成功后返回当前页面，这一步需要在登录页操作。               
78.                                 case 401:                    
79.                                         router.replace({                        
80.                                                 path: '/login',                        
81.                                                 query: {
82.                                                         redirect: router.currentRoute.fullPath
83.                                                 }
84.                                         });
85.                                         break;
87.             // 403 token过期
88.             // 登录过期对用户进行提示
89.             // 清除本地token和清空vuex中token对象
90.             // 跳转登录页面               
91.             case 403:
92.                  Toast({
93.                     message: '登录过期，请重新登录',
94.                     duration: 1000,
95.                     forbidClick: true
96.                 });
97.                 // 清除token
98.                 localStorage.removeItem('token');
99.                 store.commit('loginSuccess', null);
100.                 // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
101.                 setTimeout(() => {                        
102.                     router.replace({                           
103.                         path: '/login',                           
104.                         query: {
105.                             redirect: router.currentRoute.fullPath
106.                         }                        
107.                     });                    
108.                 }, 1000);                    
109.                 break;
111.             // 404请求不存在
112.             case 404:
113.                 Toast({
114.                     message: '网络请求不存在',
115.                     duration: 1500,
116.                     forbidClick: true
117.                 });
118.                 break;
119.             // 其他错误，直接抛出错误提示
120.             default:
121.                 Toast({
122.                     message: error.response.data.message,
123.                     duration: 1500,
124.                     forbidClick: true
125.                 });
126.         }
127.         return Promise.reject(error.response);
128.     }
129. }   
130. });
131. 响应拦截器很好理解，就是服务器返回给我们的数据，我们在拿到之前可以对他进行一些处理。例如上面的思想：如果后台返回的状态码是200，则正常返回数据，否则的根据错误的状态码类型进行一些我们需要的错误，其实这里主要就是进行了错误的统一处理和没登录或登录过期后调整登录页的一个操作。
133. 要注意的是，上面的Toast()方法，是我引入的vant库中的toast轻提示组件，你根据你的ui库，对应使用你的一个提示组件。
135. 封装get方法和post方法
136. 我们常用的ajax请求方法有get、post、put等方法，相信小伙伴都不会陌生。axios对应的也有很多类似的方法，不清楚的可以看下文档。但是为了简化我们的代码，我们还是要对其进行一个简单的封装。下面我们主要封装两个方法：get和post。
138. get方法：我们通过定义一个get函数，get函数有两个参数，第一个参数表示我们要请求的url地址，第二个参数是我们要携带的请求参数。get函数返回一个promise对象，当axios其请求成功时resolve服务器返回 值，请求失败时reject错误值。最后通过export抛出get函数。
140. /**
141. * get方法，对应get请求
142. * @param {String} url [请求的url地址]
143. * @param {Object} params [请求时携带的参数]
144. */
145. export function get(url, params){   
146.         return new Promise((resolve, reject) =>{        
147.                 axios.get(url, {            
148.                         params: params        
149.                 }).then(res => {
150.                         resolve(res.data);
151.                 }).catch(err =>{
152.                         reject(err.data)        
153.         })   
154. });}
155. post方法：原理同get基本一样，但是要注意的是，post方法必须要使用对提交从参数对象进行序列化的操作，所以这里我们通过node的qs模块来序列化我们的参数。这个很重要，如果没有序列化操作，后台是拿不到你提交的数据的。这就是文章开头我们import QS from 'qs';的原因。如果不明白序列化是什么意思的，就百度一下吧，答案一大堆。
157. /**
158. * post方法，对应post请求
159. * @param {String} url [请求的url地址]
160. * @param {Object} params [请求时携带的参数]
161. */
162. export function post(url, params) {
163.         return new Promise((resolve, reject) => {
164.                  axios.post(url, QS.stringify(params))
165.                 .then(res => {
166.                         resolve(res.data);
167.                 })
168.                 .catch(err =>{
169.                         reject(err.data)
170.                 })
171.         });
172. }
173. 这里有个小细节说下，axios.get()方法和axios.post()在提交数据时参数的书写方式还是有区别的。区别就是，get的第二个参数是一个{}，然后这个对象的params属性值是一个参数对象的。而post的第二个参数就是一个参数对象。两者略微的区别要留意哦！
175. axios的封装基本就完成了，下面再简单说下api的统一管理。
176. 整齐的api就像电路板一样，即使再复杂也能很清晰整个线路。上面说了，我们会新建一个api.js,然后在这个文件中存放我们所有的api接口。
178. 首先我们在api.js中引入我们封装的get和post方法
180. /**   
181. * api接口统一管理
182. */
183. import { get, post } from './http'
184. 现在，例如我们有这样一个接口，是一个post请求：
186. http://www.baiodu.com/api/v1/users/my_address/address_edit_before
187. 我们可以在api.js中这样封装：
189. export const apiAddress = p => post('api/v1/users/my_address/address_edit_before', p);
190. 我们定义了一个apiAddress方法，这个方法有一个参数p，p是我们请求接口时携带的参数对象。而后调用了我们封装的post方法，post方法的第一个参数是我们的接口地址，第二个参数是apiAddress的p参数，即请求接口时携带的参数对象。最后通过export导出apiAddress。
192. 然后在我们的页面中可以这样调用我们的api接口：
194. import { apiAddress } from '@/request/api';// 导入我们的api接口
195. export default {        
196.         name: 'Address',   
197.         created () {
198.                 this.onLoad();
199.         },
200.         methods: {            
201.                 // 获取数据            
202.                 onLoad() {
203.                         // 调用api接口，并且提供了两个参数               
204.                         apiAddress({                    
205.                                 type: 0,                    
206.                                 sort: 1               
207.                         }).then(res => {
208.                                 // 获取数据成功后的其他操作
209.                                 ………………               
210.                         })            
211.                 }        
212.         }
213. }
214. 其他的api接口，就在pai.js中继续往下面扩展就可以了。友情提示，为每个接口写好注释哦！！！
216. api接口管理的一个好处就是，我们把api统一集中起来，如果后期需要修改接口，我们就直接在api.js中找到对应的修改就好了，而不用去每一个页面查找我们的接口然后再修改会很麻烦。关键是，万一修改的量比较大，就规格gg了。还有就是如果直接在我们的业务代码修改接口，一不小心还容易动到我们的业务代码造成不必要的麻烦。
218. 好了，最后把完成的axios封装代码奉上。
220. /**axios封装
221. * 请求拦截、相应拦截、错误统一处理
222. */
223. import axios from 'axios';import QS from 'qs';
224. import { Toast } from 'vant';
225. import store from '../store/index'
227. // 环境的切换
228. if (process.env.NODE_ENV == 'development') {   
229.         axios.defaults.baseURL = '/api';
230. } else if (process.env.NODE_ENV == 'debug') {   
231.         axios.defaults.baseURL = '';
232. } else if (process.env.NODE_ENV == 'production') {   
233.         axios.defaults.baseURL = 'http://api.123dailu.com/';
234. }
236. // 请求超时时间
237. axios.defaults.timeout = 10000;
239. // post请求头
240. axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
242. // 请求拦截器
243. axios.interceptors.request.use(   
244.         config => {
245.                 // 每次发送请求之前判断是否存在token，如果存在，则统一在http请求的header都加上token，不用每次请求都手动添加了
246.                 // 即使本地存在token，也有可能token是过期的，所以在响应拦截器中要对返回状态进行判断
247.                 const token = store.state.token;        
248.                 token && (config.headers.Authorization = token);        
249.                 return config;   
250.         },   
251.         error => {        
252.                 return Promise.error(error);   
253.         })
255. // 响应拦截器
256. axios.interceptors.response.use(   
257.         response => {        
258.                 if (response.status === 200) {            
259.                         return Promise.resolve(response);        
260.                 } else {            
261.                         return Promise.reject(response);        
262.                 }   
263.         },
264.         // 服务器状态码不是200的情况   
265.         error => {        
266.                 if (error.response.status) {            
267.                         switch (error.response.status) {               
268.                                 // 401: 未登录               
269.                                 // 未登录则跳转登录页面，并携带当前页面的路径               
270.                                 // 在登录成功后返回当前页面，这一步需要在登录页操作。               
271.                                 case 401:                    
272.                                         router.replace({                        
273.                                                 path: '/login',                        
274.                                                 query: { redirect: router.currentRoute.fullPath }
275.                                         });
276.                                         break;
277.                                 // 403 token过期               
278.                                 // 登录过期对用户进行提示               
279.                                 // 清除本地token和清空vuex中token对象               
280.                                 // 跳转登录页面               
281.                                 case 403:                     
282.                                         Toast({                        
283.                                                 message: '登录过期，请重新登录',                        
284.                                                 duration: 1000,                        
285.                                                 forbidClick: true                    
286.                                         });                    
287.                                         // 清除token                    
288.                                         localStorage.removeItem('token');                    
289.                                         store.commit('loginSuccess', null);                    
290.                                         // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
291.                                         setTimeout(() => {                        
292.                                                 router.replace({                           
293.                                                         path: '/login',                           
294.                                                         query: {
295.                                                                 redirect: router.currentRoute.fullPath
296.                                                         }                        
297.                                                 });                    
298.                                         }, 1000);                    
299.                                         break;
300.                                 // 404请求不存在               
301.                                 case 404:                    
302.                                         Toast({                        
303.                                                 message: '网络请求不存在',                        
304.                                                 duration: 1500,                        
305.                                                 forbidClick: true                    
306.                                         });                    
307.                                 break;               
308.                                 // 其他错误，直接抛出错误提示               
309.                                 default:                    
310.                                         Toast({                        
311.                                                 message: error.response.data.message,                        
312.                                                 duration: 1500,                        
313.                                                 forbidClick: true                    
314.                                         });            
315.                         }            
316.                         return Promise.reject(error.response);        
317.                 }      
318.         }
319. );
320. /**
321. * get方法，对应get请求
322. * @param {String} url [请求的url地址]
323. * @param {Object} params [请求时携带的参数]
324. */
325. export function get(url, params){   
326.         return new Promise((resolve, reject) =>{        
327.                 axios.get(url, {            
328.                         params: params        
329.                 })        
330.                 .then(res => {            
331.                         resolve(res.data);        
332.                 })        
333.                 .catch(err => {            
334.                         reject(err.data)        
335.                 })   
336.         });
337. }
338. /**
339. * post方法，对应post请求
340. * @param {String} url [请求的url地址]
341. * @param {Object} params [请求时携带的参数]
342. */
343. export function post(url, params) {   
344.         return new Promise((resolve, reject) => {         
345.                 axios.post(url, QS.stringify(params))        
346.                 .then(res => {            
347.                         resolve(res.data);        
348.                 })        
349.                 .catch(err => {            
350.                         reject(err.data)        
351.                 })   
352.         });
353. }
354. axios的封装根据需求的不同而不同。
355. 1.优化axios封装，去掉之前的get和post
357. 2.断网情况处理
359. 3.更加模块化的api管理
361. 4.接口域名有多个的情况
363. 5.api挂载到vue.prototype上省去引入的步骤
365. http.js中axios封装的优化，先直接贴代码：
367. /**
368. * axios封装
369. * 请求拦截、响应拦截、错误统一处理
370. */
371. import axios from 'axios';
372. import router from '../router';
373. import store from '../store/index';
374. import { Toast } from 'vant';
376. /**
377. * 提示函数
378. * 禁止点击蒙层、显示一秒后关闭
379. */
380. const tip = msg => {   
381.         Toast({        
382.                 message: msg,        
383.                 duration: 1000,        
384.                 forbidClick: true   
385.         });
386. }
388. /**
389. * 跳转登录页
390. * 携带当前页面路由，以期在登录页面完成登录后返回当前页面
391. */
392. const toLogin = () => {
393.         router.replace({
394.                 path: '/login',        
395.                 query: {
396.                         redirect: router.currentRoute.fullPath
397.                 }
398.         });
399. }
401. /**
402. * 请求失败后的错误统一处理
403. * @param {Number} status 请求失败的状态码
404. */
405. const errorHandle = (status, other) => {
406.         // 状态码判断
407.         switch (status) {
408.                 // 401: 未登录状态，跳转登录页
409.                 case 401:
410.                         toLogin();
411.                         break;
412.                 // 403 token过期
413.                 // 清除token并跳转登录页
414.                 case 403:
415.                         tip('登录过期，请重新登录');
416.                         localStorage.removeItem('token');
417.                         store.commit('loginSuccess', null);
418.                         setTimeout(() => {
419.                                 toLogin();
420.                         }, 1000);
421.                         break;
422.                 // 404请求不存在
423.                 case 404:
424.                         tip('请求的资源不存在');
425.                         break;
426.                 default:
427.                         console.log(other);   
428.                 }}
430. // 创建axios实例
431. var instance = axios.create({    timeout: 1000 * 12});
432. // 设置post请求头
433. instance.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
434. /**
435. * 请求拦截器
436. * 每次请求前，如果存在token则在请求头中携带token
437. */
438. instance.interceptors.request.use(   
439.         config => {        
440.                 // 登录流程控制中，根据本地是否存在token判断用户的登录情况        
441.                 // 但是即使token存在，也有可能token是过期的，所以在每次的请求头中携带token        
442.                 // 后台根据携带的token判断用户的登录情况，并返回给我们对应的状态码        
443.                 // 而后我们可以在响应拦截器中，根据状态码进行一些统一的操作。        
444.                 const token = store.state.token;        
445.                 token && (config.headers.Authorization = token);        
446.                 return config;   
447.         },   
448.         error => Promise.error(error))
450. // 响应拦截器
451. instance.interceptors.response.use(   
452.         // 请求成功
453.         res => res.status === 200 ? Promise.resolve(res) : Promise.reject(res),   
454.         // 请求失败
455.         error => {
456.                 const { response } = error;
457.                 if (response) {
458.                         // 请求已发出，但是不在2xx的范围
459.                         errorHandle(response.status, response.data.message);
460.                         return Promise.reject(response);
461.                 } else {
462.                         // 处理断网的情况
463.                         // eg:请求超时或断网时，更新state的network状态
464.                         // network状态在app.vue中控制着一个全局的断网提示组件的显示隐藏
465.                         // 关于断网组件中的刷新重新获取数据，会在断网组件中说明
466.                         if (!window.navigator.onLine) {
467.                            store.commit('changeNetwork', false);
468.                         } else {
469.                                 return Promise.reject(error);
470.                         }
471.                 }
472.         });
474. export default instance;
475. 这个axios和之前的大同小异，做了如下几点改变：
477. 1.去掉了之前get和post方法的封装，通过创建一个axios实例然后export default方法导出，这样使用起来更灵活一些。
479. 2.去掉了通过环境变量控制baseUrl的值。考虑到接口会有多个不同域名的情况，所以准备通过js变量来控制接口域名。这点具体在api里会介绍。
481. 3.增加了请求超时，即断网状态的处理。说下思路，当断网时，通过更新vuex中network的状态来控制断网提示组件的显示隐藏。断网提示一般会有重新加载数据的操作，这步会在后面对应的地方介绍。
483. 4.公用函数进行抽出，简化代码，尽量保证单一职责原则。
485. 下面说下api这块，考虑到一下需求：
487. 1.更加模块化
489. 2.更方便多人开发，有效减少解决命名冲突
491. 3.处理接口域名有多个情况
493. 这里这里呢新建了一个api文件夹，里面有一个index.js和一个base.js，以及多个根据模块划分的接口js文件。index.js是一个api的出口，base.js管理接口域名，其他js则用来管理各个模块的接口。
495. 先放index.js代码：
497. /**
498. * api接口的统一出口
499. */
500. // 文章模块接口
501. import article from '@/api/article';
502. // 其他模块的接口……
504. // 导出接口
505. export default {   
506.         article,
507.         // ……
508. }
509. index.js是一个api接口的出口，这样就可以把api接口根据功能划分为多个模块，利于多人协作开发，比如一个人只负责一个模块的开发等，还能方便每个模块中接口的命名哦。
511. base.js:
513. /**
514. * 接口域名的管理
515. */
516. const base = {   
517.         sq: 'https://xxxx111111.com/api/v1',   
518.         bd: 'http://xxxxx22222.com/api'
519. }
521. export default base;
522. 通过base.js来管理我们的接口域名，不管有多少个都可以通过这里进行接口的定义。即使修改起来，也是很方便的。
524. 最后就是接口模块的说明，例如上面的article.js:
526. /**
527. * article模块接口列表
528. */
530. import base from './base'; // 导入接口域名列表
531. import axios from '@/utils/http'; // 导入http中创建的axios实例
532. import qs from 'qs'; // 根据需求是否导入qs模块
534. const article = {   
535.         // 新闻列表   
536.         articleList () {        
537.                 return axios.get(`${base.sq}/topics`);   
538.         },   
539.         // 新闻详情,演示   
540.         articleDetail (id, params) {        
541.                 return axios.get(`${base.sq}/topic/${id}`, {            
542.                         params: params        
543.                 });   
544.         },
545.         // post提交   
546.         login (params) {        
547.                 return axios.post(`${base.sq}/accesstoken`, qs.stringify(params));   
548.         }
549.         // 其他接口…………
550. }
552. export default article;
553. 1.通过直接引入我们封装好的axios实例，然后定义接口、调用axios实例并返回，可以更灵活的使用axios，比如你可以对post请求时提交的数据进行一个qs序列化的处理等。
555. 2.请求的配置更灵活，你可以针对某个需求进行一个不同的配置。关于配置的优先级，axios文档说的很清楚，这个顺序是：在 lib/defaults.js 找到的库的默认值，然后是实例的 defaults 属性，最后是请求的 config 参数。后者将优先于前者。
557. 3.restful风格的接口，也可以通过这种方式灵活的设置api接口地址。
559. 最后，为了方便api的调用，我们需要将其挂载到vue的原型上。在main.js中：
561. import Vue from 'vue'
562. import App from './App'
563. import router from './router' // 导入路由文件
564. import store from './store' // 导入vuex文件
565. import api from './api' // 导入api接口
567. Vue.prototype.$api = api; // 将api挂载到vue的原型上
568. 然后我们可以在页面中这样调用接口，eg：
570. methods: {   
571.         onLoad(id) {      
572.                 this.$api.article.articleDetail(id, {        
573.                         api: 123      
574.                 }).then(res=> {
575.                         // 执行某些操作      
576.                 })   
577.         }  
578. }
579. 再提一下断网的处理，这里只做一个简单的示例：
581. <template>  
582.             
583.                      
584.                         <h3>我没网了</h3>      
585.                         刷新      
586.                     
587.                 <router-view/>      
588.        
589. </template>
592. 这是app.vue，这里简单演示一下断网。在http.js中介绍了，我们会在断网的时候，来更新vue中network的状态，那么这里我们根据network的状态来判断是否需要加载这个断网组件。断网情况下，加载断网组件，不加载对应页面的组件。当点击刷新的时候，我们通过跳转refesh页面然后立即返回的方式来实现重新获取数据的操作。因此我们需要新建一个refresh.vue页面，并在其beforeRouteEnter钩子中再返回当前页面。
595. // refresh.vue
596. beforeRouteEnter (to, from, next) {
597.         next(vm => {            
598.                 vm.$router.replace(from.fullPath)        
599.         })   
600. }

复制代码

"""

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！