spring-security-oauth2做前后端分离实现无感知token续期

一时失言乱红尘 2021-09-07 06:03 508阅读 0赞

## 1.问题由来 ##

接触java已经将近3年现在大四在实习了，以前自己写的项目最多只用到了spring-security做权限认证其中的token是用jwt实现的，也考虑和使用过响应头返回新token前端判断替换token来实现访问续期的，但是总觉得不是很方便。再者就是当token过期后前端直接要求用户重新登录，这样用户体验会很不好。

现在正在学习使用spring-security-oauth2做认证和授权，登录返回的AccessToken和RefreshToken可以很好地帮助我实现token续期。**其中用到了oauth2的相关知识，在此不做解释**。  
[理解OAuth2][OAuth2]

这是一个token刷新的思路，我还在向这个方西努力  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODY0OA_size_16_color_FFFFFF_t_70_pic_center]

## 2.前端vue处理 ##

请求响应拦截添加令牌过期处理  
在判断响应结果是token过期时，执行刷新令牌方法覆盖本地的token。

在刷新期间需做到两点，一是避免重复刷新，二是请求重试，为了满足以上两点添加了两个关键变量：

refreshing----刷新标识  
在第一次access\_token过期请求失败时，调用刷新token请求时开启此标识，标识当前正在刷新中，避免后续请求因token失效重复刷新。

waitQueue----请求等待队列  
当执行刷新token期间时，需要把后来的请求先缓存到等待队列，在刷新token成功时，重新执行等待队列的请求即可。

修改请求响应封装request.js的代码如下，关键部分使用注释说明  
**响应拦截器**

// 响应拦截器
    let refreshing = false,// 正在刷新标识，避免重复刷新
      waitQueue = [] // 请求等待队列
    service.interceptors.response.use(res => { 
        // 未设置状态码则默认成功状态
        const code = res.data.code || 200;
        // 获取错误信息
        const msg = errorCode[code] || res.data.message || errorCode['default']
        console.log(code)
        if (code == 1001 ) { 
          const config = res.config
            if (refreshing == false) { 
              refreshing = true
              const refreshToken = getRefresh()
              return store.dispatch('RefreshToken', refreshToken).then((token) => { 
                console.log("成功+"+token)
                config.headers['Authorization'] = 'bearer' + token
                config.baseURL = '' // 请求重试时，url已包含baseURL
                waitQueue.forEach(callback => callback(token)) // 已刷新token，所有队列中的请求重试
                waitQueue = []
                return service(config)
              }).catch(() => {  // refresh_token也过期，直接跳转登录页面重新登录
                MessageBox.confirm('当前页面已失效，请重新登录', '确认退出', { 
                  confirmButtonText: '重新登录',
                  cancelButtonText: '取消',
                  type: 'warning'
                }).then(() => { 
                  store.dispatch('LogOut').then(() => { 
                    location.href = '/index';
                  })
                })
              }).finally(() => { 
                refreshing = false
              })
            } else { 
              // 正在刷新token，返回未执行resolve的Promise,刷新token执行回调
              return new Promise((resolve => { 
                waitQueue.push((token) => { 
                  config.headers['Authorization'] = 'bearer' + token
                  config.baseURL = '' // 请求重试时，url已包含baseURL
                  resolve(service(config))
                })
              }))
            }
    
        } else if (code === 500) { 
          Message({ 
            message: msg,
            type: 'error'
          })
          return Promise.reject(new Error(msg))
        } else if (code != 200) { 
          Notification.error({ 
            title: msg
          })
          return Promise.reject('error')
        } else { 
          return res.data
        }
      },
      error => { 
        console.log('err' + error)
        let {  message } = error;
        if (message == "Network Error") { 
          message = "后端接口连接异常";
        }
        else if (message.includes("timeout")) { 
          message = "系统接口请求超时";
        }
        else if (message.includes("Request failed with status code")) { 
          message = "系统接口" + message.substr(message.length - 3) + "异常";
        }
        Message({ 
          message: message,
          type: 'error',
          duration: 5 * 1000
        })
        return Promise.reject(error)
      }
    )

**store中封装的方法**

//刷新token
        RefreshToken({ commit}, refreshToken) { 
          commit('SET_TOKEN', undefined)
          return new Promise((resolve, reject) => { 
            axios({ 
              method:"post",
              url:`${ process.env.VUE_APP_BASE_API}/oauth/token`,
              headers: { 'Authorization': "Basic Z3------xMjM0NTY="},//通过base64加密的客户端数据
              params:{ 
                grant_type:"refresh_token",
                refresh_token:refreshToken
              },
              }).then((response)=>{ 
              const token = response.data.access_token
              const refreshToken = response.data.refresh_token
              setToken('bearer' +token)
              commit('SET_TOKEN','bearer' + token)
              setRefresh(refreshToken)
              commit('SET_Refresh',refreshToken)
              resolve(token)
              }).catch(error => { 
                reject(error)
              })
          })
        },

## 3.测试 ##

0~61s：双token都没过期，正常请求过程。  
61s~120s：access\_token过期，再次请求会执行一次刷新请求。  
120s+： refresh\_token过期，神仙都救不了，重新登录

[OAuth2]: http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODY0OA_size_16_color_FFFFFF_t_70_pic_center]: /images/20210813/3a2d3af7ca5849d48c782259f4549384.png