Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

我的token是异步从iframe的父级获取的,第一次进入页面请求拿不到token怎么处理

  1. User

    我的token是异步从iframe的父级获取的,第一次进入页面请求拿不到token怎么处理

  2. Assistant

    可以在第一次进入页面时,先设置一个定时器,等待一定的时间后再去获取token,或者在获取token的地方添加一个判断,如果没有获取到token,就多次尝试获取,直到获取到为止。同时也要确保token的获取不会影响到整个页面的正常加载和运行。

  3. User

    可以在request拦截器里写吗

  4. Assistant

    可以在request拦截器里进行处理,可以尝试类似以下的代码:

    // 在请求拦截器中获取token
    axios.interceptors.request.use(
      config => {
        // 获取token
        const token = getToken()
        // 如果token存在,添加到请求头中
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }
        return config
      },
      error => {
        return Promise.reject(error)
      }
    )
    
    // 定义获取token的方法(异步)
    function getToken() {
      return new Promise(resolve => {
        // 假设获取token的函数为getTokenAsync,可以将其封装为Promise
        getTokenAsync().then(token => {
          resolve(token)
        })
      })
    }
    
    // 在需要获取token的地方,调用getToken方法即可
    function getData() {
      getToken().then(token => {
        // 请求数据时,将token加入请求头
        axios.get('/api/data', {
          headers: {
            Authorization: `Bearer ${token}`
          }
        }).then(res => {
          console.log(res.data)
        })
      })
    }
    

    这样可以保证在请求数据时,能够获取到最新的token,并作为请求头的一部分一起发送请求。同时,也不会影响到整个页面的正常加载和运行。

  5. User

    我的token是在App.vue通过message事件接收的,这样要怎么保证第一次请求就能加上token

  6. Assistant

    可以在App.vue中接收到token后,将其保存到localStorage中,在请求拦截器中获取token时,先从localStorage中获取,再从消息中心中获取,如果在localStorage中没有获取到,则再从消息中心中获取。如果在获取到的token存在,则将其加入到请求头中。

    可以尝试类似以下的代码:

    // App.vue
    mounted() {
      window.addEventListener('message', this.onMessage)
    },
    methods: {
      onMessage(event) {
        // 接收到token后,保存到localStorage中
        localStorage.setItem('token', event.data.token)
      }
    }
    
    // axios拦截器
    axios.interceptors.request.use(
      config => {
        // 从localStorage中获取token
        const token = localStorage.getItem('token')
        // 如果localStorage中没有获取到,再从消息中心获取
        if (!token) {
          const messageToken = getMessageToken()
          // 如果消息中心有token,则保存到localStorage中,并返回token
          if (messageToken) {
            localStorage.setItem('token', messageToken)
            return `Bearer ${messageToken}`
          }
          // 没有获取到token,则终止请求
          return Promise.reject(new Error('没有获取到token'))
        }
        // token存在,则加入到请求头中
        config.headers.Authorization = `Bearer ${token}`
        return config
      },
      error => {
        return Promise.reject(error)
      }
    )
    
    // 定义从消息中心中获取token的方法(异步)
    function getMessageToken() {
      return new Promise(resolve => {
        window.parent.postMessage({ type: 'get-token' }, '*')
        window.addEventListener('message', event => {
          if (event.data.token) {
            resolve(event.data.token)
          } else {
            resolve(null)
          }
        })
      })
    }
    

    这样可以保证在请求拦截器中获取到最新的token,并将其加入到请求头中,确保请求能够顺利进行。这里假设获取token的函数是异步的,因此需要将其封装为Promise,以便在请求拦截器中使用。

  7. User

    我的axios是在外面写的,可以通过反复从localStorage中获取token吗

  8. Assistant

    可以将token从localStorage中获取到,并赋值给一个全局变量,这样可以避免在每次请求时都从localStorage中获取token。如果localStorage中没有获取到token,则再从消息中心获取,并将获取到的token保存到localStorage中和全局变量中。在每次请求时,都将全局变量中的token添加到请求头中。

    可以尝试类似以下的代码:

    // 定义一个全局变量,用于保存token
    let token = null
    
    // 定义获取token的方法(异步)
    function getToken() {
      return new Promise(resolve => {
        // 先从全局变量中获取token
        if (token) {
          resolve(token)
          return
        }
        
        // 如果全局变量中没有token,则从localStorage中获取
        const localStorageToken = localStorage.getItem('token')
        if (localStorageToken) {
          token = localStorageToken
          resolve(token)
          return
        }
        
        // 如果localStorage中没有token,则从消息中心获取
        window.parent.postMessage({ type: 'get-token' }, '*')
        window.addEventListener('message', event => {
          if (event.data.token) {
            token = event.data.token
            localStorage.setItem('token', token)
            resolve(token)
          } else {
            resolve(null)
          }
        })
      })
    }
    
    // axios拦截器
    axios.interceptors.request.use(
      config => {
        // 获取token,并将其加入请求头中
        getToken().then(token => {
          if (token) {
            config.headers.Authorization = `Bearer ${token}`
          }
        })
        return config
      },
      error => {
        return Promise.reject(error)
      }
    )
    

    这样可以避免在每次请求时都从localStorage中获取token,也不会影响整个应用的正常运行。在需要获取token的地方,可以调用getToken方法,以获取最新的token。

  9. User

    我的token是存在vuex里的,axios是单独封装的

  10. Assistant

    如果你的token存在vuex中,可以通过在封装的axios中定义一个拦截器,在发送请求的时候获取vuex中的token,并设置到请求头中。

    可以尝试类似以下的代码:

    // request.js
    import axios from 'axios'
    import store from '@/store'
    
    const instance = axios.create({
      baseURL: process.env.API_BASE_URL,
      timeout: 10000
    })
    
    // 在请求拦截器中设置token,要求是异步的
    instance.interceptors.request.use(async function(config) {
      // 获取vuex中的token
      const token = await store.dispatch('getToken')
      if (token) {
        config.headers.Authorization = 'Bearer ' + token
      }
      return config;
    }, function(error) {
      return Promise.reject(error);
    });
    
    // 导出封装后的axios实例
    export default instance
    

    这样定义后,每当请求被发送时,会将token从vuex中获取到并设置到请求头中,即使token发生改变,也能够正常地发送请求。然后你需要在vuex的action中定义一个获取token的方法:

    // store.js
    const store = new Vuex.Store({
      state: {
        token: null
      },
      mutations: {
        setToken (state, token) {
          state.token = token
        }
      },
      actions: {
        getToken ({ commit }) {
          // 获取token并存到vuex中
          return new Promise((resolve, reject) => {
            if (this.state.token) {
              resolve(this.state.token)
            } else {
              window.addEventListener('message', event => {
                if (event.data.token) {
                  commit('setToken', event.data.token)
                  resolve(event.data.token)
                } else {
                  resolve(null)
                }
              })
              window.parent.postMessage({ type: 'get-token' }, '*')
            }
          })
        }
      }
    })
    

    在该方法中异步获取token,如果vuex中token已存在,则直接返回vuex存储的token,如果token不存在,则异步从iframe的父级获取token,并将token存到vuex中,同时返回获取到的token。最后在组件的请求方法中使用封装后的axios, 并处理结果即可。

    // component.vue
    import request from '@/utils/request'
    
    export default {
      methods: {
        async fetchData () {
          try {
            const res = await request.get('/api/data')
            // 处理请求结果
          } catch (e) {
            console.log('请求出错:', e)
          }
        }
      }
    }
    

    这样即可在请求头中就包含上vuex中存储的token,请求能够正常发送。

  11. User

    我要在本地环境用延时模拟获取token

  12. Assistant

    可以将获取token的过程封装为一个Promise,然后利用setTimeout或setInterval模拟延时,等待一段时间后再返回token。可以尝试类似以下的代码:

    // 定义获取token的方法
    function getToken() {
      return new Promise((resolve, reject) => {
        // 模拟延时获取token
        setTimeout(() => {
          const token = 'YOUR_TOKEN_HERE'
          if (token) {
            resolve(token)
          } else {
            reject(new Error('没有获取到token'))
          }
        }, 2000) // 延时2秒后再返回token
      })
    }
    
    // 在请求拦截器中获取token
    axios.interceptors.request.use(
      config => {
        // 获取token,并将其加入请求头中
        getToken().then(token => {
          config.headers.Authorization = `Bearer ${token}`
        })
        return config
      },
      error => {
        return Promise.reject(error)
      }
    )
    

    这样可以模拟延时获取token的场景,等待一定时间后再去获取token并添加到请求头中。在生产环境中,直接用真实的token即可,无需模拟延时。

  13. User

    在vuex里定义获取token的方法

  14. Assistant

    在vuex中定义获取token的方法,类似于下面这样:

    // store.js
    const store = new Vuex.Store({
      state: {
        token: null
      },
      mutations: {
        setToken (state, token) {
          state.token = token
        }
      },
      actions: {
        // 定义异步获取token的方法
        async getToken({state, commit}) {
          // 如果token已存在,则直接返回
          if (state.token) {
            return state.token
          }
    
          // 模拟延时获取token
          await new Promise(resolve => {
            setTimeout(() => {
              const token = 'YOUR_TOKEN_HERE'
              if (token) {
                commit('setToken', token)
                resolve(token)
              } else {
                resolve(null)
              }
            }, 1000)
          })
    
          return state.token
        }
      }
    })
    

    注意:如果你要在vuex中使用axios,需要将axios作为参数传入,并在getToken方法中调用axios获取token,然后将获取到的token存入vuex中。

    在组件中使用该方法:

    // component.vue
    import { mapActions } from 'vuex'
    
    export default {
      methods: {
        ...mapActions(['getToken']),
        async fetchData() {
          try {
            const token = await this.getToken()
            // 在请求头中加上token
            axios.defaults.headers.common['Authorization'] = `Bearer ${token}`
    
            const res = await axios.get('/api/data')
            // 处理请求结果
          } catch (e) {
            console.log('请求出错:', e)
          }
        }
      }
    }
    

    在该方法中,先调用vuex中封装好的getToken方法获取token,然后将获取到的token添加到axios的请求头中。最后使用axios进行请求,并处理结果。

    这样可以保证在请求数据时,能够获取到最新的token,并作为请求头的一部分一起发送请求。同时,也不会影响到整个页面的正常加载和运行。

  15. User

    我要在封装的axios里用actions里的getToken

  16. Assistant

    可以在封装的axios里调用vuex store里的actions方法getToken,获取token后添加到请求头中。

    可以尝试类似以下的代码:

    // request.js
    import axios from 'axios'
    import store from '@/store'
    
    const instance = axios.create({
      baseURL: process.env.API_BASE_URL,
      timeout: 10000
    })
    
    // 在请求拦截器中设置token,要求是异步的
    instance.interceptors.request.use(async (config) => {
      try {
        // 在请求头中添加token
        const token = await store.dispatch('getToken')
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }
      } catch (error) {
        console.error('获取token失败:', error.message)
      }
    
      return config;
    }, function(error) {
      return Promise.reject(error);
    });
    
    // 导出封装后的axios实例
    export default instance
    

    在请求拦截器中,通过调用store.dispatch('getToken'),异步获取token,并将获取到的token添加到请求头中。

    然后你需要在vuex的action中定义调用API的方法getToken,这里返回的是一个包含token的Promise:

    // store.js
    const store = new Vuex.Store({
      state: {
        token: null
      },
      mutations: {
        setToken (state, token) {
          state.token = token
        }
      },
      actions: {
        getToken ({ state, commit }) {
          // 如果token存在就直接返回Promise.resolve并传入token 
          if (state.token) {
            return Promise.resolve(state.token)
          }
          // 若token不存在
          return new Promise((resolve, reject) => {
            window.parent.postMessage({ type: 'get-token' }, '*')
            window.addEventListener('message', event => {
              if (event.data.token) {
                commit('setToken', event.data.token)
                resolve(event.data.token)
              } else {
                resolve(null)
              }
            })
          })
        }
      }
    })
    

    再在组件的请求方法中使用封装后的axios,即可在请求头中带上token:

    // component.vue
    import request from '@/utils/request'
    
    export default {
      methods: {
        async fetchData () {
          try {
            const res = await request.get('/api/data')
            // 处理请求结果
          } catch (e) {
            console.log('请求出错:', e)
          }
        }
      }
    }
    

    这样写可以将封装的axios直接作为一个模块,并在项目中使用,保证了获取到最新的token,并且请求头中带上了token。