@Component
public class MyAccessFilter implements GlobalFilter, Ordered
{
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String uri = request.getURI().getPath();
        HttpMethod method = request.getMethod();

        // OPTION直接放行
        if(method.matches(HttpMethod.OPTIONS.name()))
            return chain.filter(exchange);

        //登錄請(qǐng)求直接放行
        if(SecurityAccessConstant.REQUEST_LOGGING_URI.equals(uri) && method.matches(HttpMethod.POST.name()))
            return chain.filter(exchange);
   
       //獲取token
        String token = JWTHelper.getToken(request.getHeaders().getFirst(SecurityAccessConstant.HEADER_NAME_TOKEN));
        if(null != token){
            //判斷token是否過(guò)時(shí)
            if(!JWTHelper.isOutDate(token)){
                return chain.filter(exchange);
            }else{
                if(!SecurityAccessConstant.REQUEST_REFRESH.equals(uri))    //當(dāng)前不是刷新請(qǐng)求可以刷新返回的狀態(tài)碼就是511
                    return ResponseUtils.out(exchange , ResultData.fail(ResultCodeEnum.NEED_TO_REFRESH_TOKEN.getCode(),
                        ResultCodeEnum.NEED_TO_REFRESH_TOKEN.getMessage()));
                //當(dāng)前是刷新請(qǐng)求 但refreshToken都過(guò)期了，即刷新不支持
                return ResponseUtils.out(exchange , ResultData.fail(ResultCodeEnum.RC401.getCode(), ResultCodeEnum.RC401.getMessage()));
            }

        }
        return ResponseUtils.out(exchange , ResultData.fail(ResultCodeEnum.RC401.getCode(), ResultCodeEnum.RC401.getMessage()));
    }

    @Override
    public int getOrder() {
        //數(shù)值越小 優(yōu)先級(jí)越高
        return Ordered.LOWEST_PRECEDENCE;
    }
}

//判斷當(dāng)前token是否過(guò)期
public static boolean isOutDate(String token){
    try {
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);
        Date expirationDate = claimsJws.getBody().getExpiration();
        return expirationDate.before(new Date());
    } catch (JwtException e) {
        // JWT token無(wú)效或已損壞
        return true;
    }
}

// 響應(yīng)攔截器
service.interceptors.response.use(
 
  // 響應(yīng)成功進(jìn)入第1個(gè)函數(shù)
  // 該函數(shù)的參數(shù)是響應(yīng)對(duì)象
  function(response) {
    console.log(response)
    return response.data.data;
  },
  // 響應(yīng)失敗進(jìn)入第2個(gè)函數(shù)，該函數(shù)的參數(shù)是錯(cuò)誤對(duì)象
  async function(error) {
    // 如果響應(yīng)碼是 401 ，則請(qǐng)求獲取新的 token
    // 響應(yīng)攔截器中的 error 就是那個(gè)響應(yīng)的錯(cuò)誤對(duì)象
    if(error.response == undefined)
      return Promise.reject(error);

    const status = error.response.status
    const authStore = useAuthStore()
    let message = ''

    switch(status){
      case 401: // 無(wú)權(quán)限
        authStore.reset() // 清空store中的權(quán)限數(shù)據(jù)
        window.sessionStorage.removeItem('isAuthenticated')
        window.sessionStorage.removeItem('token')
        window.sessionStorage.removeItem('refreshToken')
        message = 'token 失效，請(qǐng)重新登錄'
        // 跳轉(zhuǎn)到登錄頁(yè)  
        window.location.href = '/auth/login';
        break;
      case 511: // 當(dāng)前token需要刷新
        try {
          const data = refresh()

          if(data !== null){
            data.then((value) => {
              // Use the string value here
              if(value !== ''){
                // 如果獲取成功，則把新的 token 更新到容器中
                console.log("刷新 token  成功", value);
                window.sessionStorage.setItem("token",value)
                // 把之前失敗的用戶(hù)請(qǐng)求繼續(xù)發(fā)出去
                // config 是一個(gè)對(duì)象，其中包含本次失敗請(qǐng)求相關(guān)的那些配置信息，例如 url、method 都有
                // return 把 request 的請(qǐng)求結(jié)果繼續(xù)返回給發(fā)請(qǐng)求的具體位置
                error.config.headers['Authorization'] = 'Bearer ' +value;
                return service(error.config);
              }
              console.log(value);
            }).catch((error) => {
              // Handle any errors that occurred while resolving the promise
              console.error(error);
            });
            
          }
          
        } catch (err) {
          // 如果獲取失敗，直接跳轉(zhuǎn) 登錄頁(yè)
          console.log("請(qǐng)求刷線(xiàn) token 失敗", err);
          router.push("/login");
        }
        break;
        case '403':
          message = '拒絕訪問(wèn)'
          break;
        case '404':
          message = '請(qǐng)求地址錯(cuò)誤'
          break;
        case '500':
          message = '服務(wù)器故障'
          break;
        default:
          message = '網(wǎng)絡(luò)連接故障'  
   
    }
    
    Message.error(message)
    return Promise.reject(error);
  }
);

/**
 * 刷新token 
 * 成功返回新token
 * 失敗返回空字符串''
 */
export async function refresh() : Promise<string>{
  const refreshToken = window.sessionStorage.getItem("refreshToken")
  console.log("in >>> " ,refreshToken)
  if(refreshToken == undefined)
      return '' //本來(lái)就沒(méi)有這個(gè)更新token則直接返回
  
  try {
    const response = await axios({
      method: 'GET',
      url: 'http://127.0.0.1:9001/api/simple/cloud/access/refresh',// 認(rèn)證服務(wù)器地址
      headers: {
        Authorization: `Bearer ${refreshToken}`, //header中放入的是refreshToken用于刷新請(qǐng)求
      },
    });
  // 如果順利返回會(huì)得到 data，由于后端使用統(tǒng)一結(jié)果返回ResultData，所以會(huì)多封裝一層code、data
    if (response.data) {
      return response.data.data; //所以這里有兩個(gè)data
    } else {
      return '';
    }
  } catch (error) {
    console.log(error);
    return '';
  }
}

import { refresh } from "@/api/system/auth/index"
import { jwtDecode } from "jwt-decode";

export class MyTimer {
  private timerId: any | null = null;
  // delay為重復(fù)探查的間隔時(shí)間 ， minCheck是判斷token是否是快過(guò)期的
   start(delay: number, minCheck : number): void {
     this.timerId = setInterval(async () => {
       const currentToken = window.sessionStorage.getItem('token');
       console.log("timer++++")
       if (currentToken) {
         // 如果存在token，判斷是否過(guò)期
         let expirationTime = 0;
         expirationTime = getExpirationTime(currentToken) ; // 假設(shè)有一個(gè)函數(shù)用于獲取token的過(guò)期時(shí)間
         
         const timeRemaining = expirationTime - Date.now();
         if (timeRemaining <= minCheck) {
           // 如果剩余時(shí)間小于等于5分鐘，則異步發(fā)送刷新請(qǐng)求并更新token
           await refresh();
         }
       } else {
         // 如果不存在token，則直接發(fā)送刷新請(qǐng)求并更新token
         await refresh();
       }
   }, delay);
   }
 
   stop(): void {
     if (this.timerId !== null) {
       clearInterval(this.timerId);
       this.timerId = null;
     }
   }
 }
// 獲取過(guò)期時(shí)間
 function getExpirationTime(rawToken:string) : number{
   const res = jwtDecode(rawToken)
   
   return res.exp as number
 }

import { MyTimer } from "@/utils/tokenMonitor"

const submit = () => {
  if (validate()) {
    login(formData)
      .then((data: UserInfoRes) => {
        if (data) {
          // 在這里添加需要執(zhí)行的操作
          const token = data.token;

          // 將token存儲(chǔ)到authStore中
          const authStore = useAuthStore()
          authStore.setToken(token)
          window.sessionStorage.setItem('token', token)
          window.sessionStorage.setItem('refreshToken', data.refreshToken)
          authStore.setIsAuthenticated(true)
          window.sessionStorage.setItem('isAuthenticated', 'true')
          authStore.setName(data.name)
          authStore.setButtons(data.buttons)
          authStore.setRoles(data.roles)
          authStore.setRouters(data.routers)
  //新增 引入計(jì)時(shí)器》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
          const clock = new MyTimer();
          clock.start(1000*30,1000*30);

          init({ message: "logged in success", color: 'success' });
          push({ name: 'dashboard' })

        }
      })
      .catch(() => {
        init({ message: "logged in fail , please check carefully!", color: '#FF0000' });
      });

  }else{
    Message.error('error submit!!')
    return false
  }
}

// 獲取當(dāng)前token過(guò)期時(shí)間 這里不判斷是否過(guò)期因?yàn)槭峭ㄟ^(guò)了過(guò)期判斷才進(jìn)來(lái)的
public static Date getExpirationDate(String token) {
    if(StringUtil.isBlank(token))
        return null;

    Claims claims = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody();
    return claims.getExpiration();
}

//存放token到請(qǐng)求頭中
String[] tokenArray = JWTHelper.createToken(sysUser.getId(), sysUser.getEmail(), permsList);
map.put("token",tokenArray[0]);
// 新增設(shè)置過(guò)期時(shí)間 毫秒數(shù)
map.put("tokenExpire",JWTHelper.getExpirationDate(tokenArray[0]).getTime());
map.put("refreshToken",tokenArray[1]);

import { refresh } from "@/api/system/auth/index"

class MyTimer {
    private timerId: any | null = null;
    private delay: number; //執(zhí)行間隔時(shí)間
    private minCheck: number; //判斷token過(guò)期時(shí)間是否小于該值

    private static instance: MyTimer;

    public static getInstance(): MyTimer {
      if (!MyTimer.instance) {
        MyTimer.instance = new MyTimer();
      }
      return MyTimer.instance;
    }

    private constructor() {
      this.delay = 30000; // Default delay value in milliseconds
      this.minCheck = 60000; // Default minCheck value in milliseconds (1 minutes)
    }
 //啟動(dòng)監(jiān)控器的方法
    start(): void {
      this.timerId = setInterval(async () => {
        const currentToken = window.sessionStorage.getItem('token');
        console.log("timer++++",currentToken)
        if (currentToken) {
          // 如果存在token，判斷是否過(guò)期
          const tokenExpireStr = window.sessionStorage.getItem('tokenExpire') as string// 假設(shè)有一個(gè)函數(shù)用于獲取token的過(guò)期時(shí)間
          const expirationTime = parseInt(tokenExpireStr, 10); //以10進(jìn)制轉(zhuǎn)換string字符串
          const timeRemaining = expirationTime - Date.now();
          console.log("ttime sub++++",timeRemaining)
          if (timeRemaining <= this.minCheck) {
            // 如果剩余時(shí)間小于等于minCheck分鐘，則異步發(fā)送刷新請(qǐng)求并更新token
            try{
              await refresh();
            }catch (error) {
              console.error('刷新失?。?, error);
              window.sessionStorage.removeItem('isAuthenticated')
              window.sessionStorage.removeItem('token')
              window.sessionStorage.removeItem('refreshToken')
              Message.error("token reflesh got some ploblem , please login")
              // 跳轉(zhuǎn)到登錄頁(yè)的代碼
              window.location.href = '/auth/login';
            }
          }
        } else {
          Message.error("token invalidate , please login")
          // token不存在 則跳轉(zhuǎn)到登錄頁(yè)  
          window.location.href = '/auth/login';
        }
    }, this.delay);

    console.log(this.timerId)
    }
  //關(guān)閉監(jiān)控器的方法
    stop(): void {
      if (this.timerId !== null) {
        clearInterval(this.timerId);
        this.timerId = null;
      }
    }
 //提供設(shè)置監(jiān)控器的刷新間隔和需要刷新的閾值
    setDelay(delay: number): void {
      this.delay = delay;
    }
  
    setMinCheck(minCheck: number): void {
      this.minCheck = minCheck;
    }
  }
//導(dǎo)出全局唯一的實(shí)例方便管理
 export const myFilterInstance = MyTimer.getInstance();
// 加到每一個(gè)頁(yè)面上，當(dāng)頁(yè)面刷新時(shí)候則重啟定時(shí)器，防止定時(shí)器刷掉
 export function onPageRender(){
    // Stop the current timer if it's running
    myFilterInstance.stop();

    // Start the timer with the updated delay and minCheck values
    myFilterInstance.start();
 }

import { onPageRender } from '@/utils/tokenMonitor'
// 新增一個(gè)監(jiān)聽(tīng)器，在頁(yè)面渲染時(shí)候執(zhí)行
window.addEventListener('load', () => {
  onPageRender();
});

// 向認(rèn)證服務(wù)器發(fā)送請(qǐng)求，獲取新的token
 Mono<ResultData> newTokenMono = WebClient.create().get()
         .uri(buildUri(SecurityAccessConstant.WEB_REQUEST_TO_AUTH_URL+SecurityAccessConstant.REQUEST_REFRESH
                 , new String[]{"refreshToken", token}))
         .retrieve()
         .bodyToMono(ResultData.class);


 // 原子操作
 AtomicBoolean isPass = new AtomicBoolean(false);
 //訂閱數(shù)據(jù)
 newTokenMono.subscribe(resultData -> {
     if(resultData.getCode() == "200"){
         exchange.getRequest().getHeaders().set(SecurityAccessConstant.HEADER_NAME_TOKEN,
                 SecurityAccessConstant.TOKEN_PREFIX + resultData.getData());
         isPass.set(true);
     }

 }).dispose(); // 銷(xiāo)毀資源

 if(isPass.get()){
     // 如果成功獲取到資源（新token則發(fā)送新請(qǐng)求）
     return chain.filter(exchange.mutate().request().build());
 }