package com.huan.study.security.token;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.huan.study.security.configuration.TokenProperties;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * @author huan 2020-06-07 - 14:34
 */
@Component
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@Slf4j
public class TokenAuthenticateFilter extends OncePerRequestFilter {

  private final TokenProperties tokenProperties;
  private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    // 獲取 認(rèn)證頭
    String authorizationHeader = request.getHeader(tokenProperties.getAuthorizationHeaderName());
    if (!checkIsTokenAuthorizationHeader(authorizationHeader)) {
      log.debug("獲取到認(rèn)證頭Authorization的值:[{}]但不是我們系統(tǒng)中登錄后簽發(fā)的。", authorizationHeader);
      filterChain.doFilter(request, response);
      return;
    }
    // 獲取到真實(shí)的token
    String realToken = getRealAuthorizationToken(authorizationHeader);
    // 解析 jwt token
    Jws<Claims> jws = JwtUtils.parserAuthenticateToken(realToken, tokenProperties.getSecretKey());
    // token 不合法
    if (null == jws) {
      writeJson(response, "認(rèn)證token不合法");
      return;
    }
    // token 是否過(guò)期
    if (JwtUtils.isJwtExpired(jws)) {
      // 處理過(guò)期
      handleTokenExpired(response, request, filterChain);
      return;
    }

    // 構(gòu)建認(rèn)證對(duì)象
    JwtUtils.buildAuthentication(jws, tokenProperties.getUserId());

    filterChain.doFilter(request, response);
  }

  /**
   * 處理token過(guò)期情況
   *
   * @param response
   * @param request
   * @param filterChain
   * @return
   * @throws IOException
   */
  private void handleTokenExpired(HttpServletResponse response, HttpServletRequest request, FilterChain filterChain) throws IOException, ServletException {
    // 獲取刷新 token
    String refreshTokenHeader = request.getHeader(tokenProperties.getRefreshHeaderName());
    // 檢測(cè) refresh-token 是否是我們系統(tǒng)中簽發(fā)的
    if (!checkIsTokenAuthorizationHeader(refreshTokenHeader)) {
      log.debug("獲取到刷新認(rèn)證頭:[{}]的值:[{}]但不是我們系統(tǒng)中登錄后簽發(fā)的。", tokenProperties.getRefreshHeaderName(), refreshTokenHeader);
      writeJson(response, "token過(guò)期了，refresh token 不是我們系統(tǒng)簽發(fā)的");
      return;
    }
    // 解析 refresh-token
    Jws<Claims> refreshToken = JwtUtils.parserAuthenticateToken(getRealAuthorizationToken(refreshTokenHeader),
        tokenProperties.getSecretKey());
    // 判斷 refresh-token 是否不合法
    if (null == refreshToken) {
      writeJson(response, "refresh token不合法");
      return;
    }
    // 判斷 refresh-token 是否過(guò)期
    if (JwtUtils.isJwtExpired(refreshToken)) {
      writeJson(response, "refresh token 過(guò)期了");
      return;
    }
    // 重新簽發(fā) token

    String newToken = JwtUtils.generatorJwtToken(
        refreshToken.getBody().get(tokenProperties.getUserId()),
        tokenProperties.getUserId(),
        tokenProperties.getTokenExpireSecond(),
        tokenProperties.getSecretKey()
    );
    response.addHeader(tokenProperties.getAuthorizationHeaderName(), newToken);

    // 構(gòu)建認(rèn)證對(duì)象
    JwtUtils.buildAuthentication(JwtUtils.parserAuthenticateToken(newToken, tokenProperties.getSecretKey()), tokenProperties.getUserId());

    filterChain.doFilter(request, response);
  }

  /**
   * 寫 json 數(shù)據(jù)給前端
   *
   * @param response
   * @throws IOException
   */
  private void writeJson(HttpServletResponse response, String msg) throws IOException {
    response.setCharacterEncoding(StandardCharsets.UTF_8.name());
    response.setContentType(MediaType.APPLICATION_JSON_VALUE);
    response.setStatus(HttpStatus.UNAUTHORIZED.value());
    Map<String, String> params = new HashMap<>(4);
    params.put("msg", msg);
    response.getWriter().print(OBJECT_MAPPER.writeValueAsString(params));
  }

  /**
   * 獲取到真實(shí)的 token 串
   *
   * @param authorizationToken
   * @return
   */
  private String getRealAuthorizationToken(String authorizationToken) {
    return StringUtils.substring(authorizationToken, tokenProperties.getTokenHeaderPrefix().length()).trim();
  }

  /**
   * 判斷是否是系統(tǒng)中登錄后簽發(fā)的token
   *
   * @param authorizationHeader
   * @return
   */
  private boolean checkIsTokenAuthorizationHeader(String authorizationHeader) {
    if (StringUtils.isBlank(authorizationHeader)) {
      return false;
    }
    if (!StringUtils.startsWith(authorizationHeader, tokenProperties.getTokenHeaderPrefix())) {
      return false;
    }
    return true;
  }
}

package com.huan.study.security.token;

import io.jsonwebtoken.*;
import io.jsonwebtoken.impl.DefaultJws;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.TestingAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;

/**
 * jwt 工具類
 *
 * @author huan
 * @date 2020-05-20 - 17:09
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class JwtUtils {

  /**
   * 解析 jwt token
   *
   * @param token   需要解析的json
   * @param secretKey 密鑰
   * @return
   */
  public static Jws<Claims> parserAuthenticateToken(String token, String secretKey) {
    try {
      final Jws<Claims> claimsJws = Jwts.parser()
          .setSigningKey(secretKey)
          .parseClaimsJws(token);
      return claimsJws;
    } catch (ExpiredJwtException e) {
      return new DefaultJws<>(null, e.getClaims(), "");
    } catch (UnsupportedJwtException | MalformedJwtException | SignatureException | IllegalArgumentException | IncorrectClaimException e) {
      log.error(e.getMessage(), e);
      return null;
    }
  }

  /**
   * 判斷 jwt 是否過(guò)期
   *
   * @param jws
   * @return true:過(guò)期 false:沒(méi)過(guò)期
   */
  public static boolean isJwtExpired(Jws<Claims> jws) {
    return jws.getBody().getExpiration().before(new Date());
  }

  /**
   * 構(gòu)建認(rèn)證過(guò)的認(rèn)證對(duì)象
   */
  public static Authentication buildAuthentication(Jws<Claims> jws, String userIdFieldName) {
    Object userId = jws.getBody().get(userIdFieldName);
    TestingAuthenticationToken testingAuthenticationToken = new TestingAuthenticationToken(userId, null, new ArrayList<>(0));
    SecurityContextHolder.getContext().setAuthentication(testingAuthenticationToken);
    return SecurityContextHolder.getContext().getAuthentication();
  }

  /**
   * 生成 jwt token
   */
  public static String generatorJwtToken(Object loginUserId, String userIdFieldName, Long expireSecond, String secretKey) {
    Date expireTime = Date.from(LocalDateTime.now().plusSeconds(expireSecond).atZone(ZoneId.systemDefault()).toInstant());
    return Jwts.builder()
        .setHeaderParam("typ", "JWT")
        .setIssuedAt(new Date())
        .setExpiration(expireTime)
        .claim(userIdFieldName, loginUserId)
        .signWith(SignatureAlgorithm.HS256, secretKey)
        .compact();
  }
}