微服務的用戶認證與授權雜談（下）

[TOC]

AOP實現登錄狀態檢查

在微服務的用戶認證與授權雜談（上）一文中簡單介紹了微服務下常見的幾種認證授權方案，並且使用JWT編寫了一個極簡demo來模擬Token的頒發及校驗。而本文的目的主要是延續上文來補充幾個要點，例如Token如何在多個微服務間進行傳遞，以及如何利用AOP實現登錄態和權限的統一校驗。

爲了讓登錄態的檢查邏輯能夠通用，我們一般會選擇使用過濾器、攔截器以及AOP等手段來實現這個功能。而本小節主要是介紹使用AOP實現登錄狀態檢查，因爲利用AOP同樣可以攔截受保護的資源訪問請求，在對資源訪問前先做一些必要的檢查。

首先需要在項目中添加AOP的依賴：

<!-- AOP -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

定義一個註解，用於標識哪些方法在被訪問之前需要進行登錄態的檢查。具體代碼如下：

package com.zj.node.usercenter.auth;

/**
 * 被該註解標記的方法都需要檢查登錄狀態
 *
 * @author 01
 * @date 2019-09-08
 **/
public @interface CheckLogin {
}

編寫一個切面，實現登錄態檢查的具體邏輯，代碼如下：

package com.zj.node.usercenter.auth;

import com.zj.node.usercenter.util.JwtOperator;
import io.jsonwebtoken.Claims;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.BooleanUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * 登錄態檢查切面類
 *
 * @author 01
 * @date 2019-09-08
 **/
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class CheckLoginAspect {

    private static final String TOKEN_NAME = "X-Token";

    private final JwtOperator jwtOperator;

    /**
     * 在執行@CheckLogin註解標識的方法之前都會先執行此方法
     */
    @Around("@annotation(com.zj.node.usercenter.auth.CheckLogin)")
    public Object checkLogin(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取request對象
        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 從header中獲取Token
        String token = request.getHeader(TOKEN_NAME);

        // 校驗Token是否合法
        Boolean isValid = jwtOperator.validateToken(token);
        if (BooleanUtils.isFalse(isValid)) {
            log.warn("登錄態校驗不通過，無效的Token：{}", token);
            // 拋出自定義異常
            throw new SecurityException("Token不合法！");
        }

        // 校驗通過，可以設置用戶信息到request裏
        Claims claims = jwtOperator.getClaimsFromToken(token);
        log.info("登錄態校驗通過，用戶名：{}", claims.get("userName"));
        request.setAttribute("id", claims.get("id"));
        request.setAttribute("userName", claims.get("userName"));
        request.setAttribute("role", claims.get("role"));

        return joinPoint.proceed();
    }
}

然後編寫兩個接口用於模擬受保護的資源和獲取token。代碼如下：

@Slf4j
@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;
    private final JwtOperator jwtOperator;

    /**
     * 需要校驗登錄態後才能訪問的資源
     */
    @CheckLogin
    @GetMapping("/{id}")
    public User findById(@PathVariable Integer id) {
        log.info("get request. id is {}", id);
        return userService.findById(id);
    }

    /**
     * 模擬生成token
     *
     * @return token
     */
    @GetMapping("gen-token")
    public String genToken() {
        Map<String, Object> userInfo = new HashMap<>();
        userInfo.put("id", 1);
        userInfo.put("userName", "小眀");
        userInfo.put("role", "user");

        return jwtOperator.generateToken(userInfo);
    }
}

最後我們來進行一個簡單的測試，看看訪問受保護的資源時是否會先執行切面方法來檢查登錄態。首先啓動項目獲取token：

在訪問受保護的資源時在header中帶上token：

訪問成功，此時控制檯輸出如下：

Tips：

這裏之所以沒有使用過濾器或攔截器來實現登錄態的校驗，而是採用了AOP，這是因爲使用AOP寫出來的代碼比較乾淨並且可以利用自定義註解實現可插拔的效果，例如訪問某個資源不用進行登錄態檢查了，那麼只需要把@CheckLogin註解給去掉即可。另外就是AOP屬於比較重要的基礎知識，也是在面試中經常被問到的知識點，通過這個實際的應用例子，可以讓我們對AOP的使用技巧有一定的瞭解。

當然也可以選擇過濾器或攔截器來實現，沒有說哪種方式就是最好的，畢竟這三種方式都有各自的特性和優缺點，需要根據具體的業務場景來選擇。

Feign實現Token傳遞

在微服務架構中通常會使用Feign來調用其他微服務所提供的接口，若該接口需要對登錄態進行檢查的話，那麼就得傳遞當前客戶端請求所攜帶的Token。而默認情況下Feign在請求其他服務的接口時，是不會攜帶任何額外信息的，所以此時我們就得考慮如何在微服務之間傳遞Token。

讓Feign實現Token的傳遞還是比較簡單的，主要有兩種方式，第一種是使用Spring MVC的@RequestHeader註解。如下示例：

@FeignClient(name = "order-center")
public interface OrderCenterService {

    @GetMapping("/orders/{id}")
    OrderDTO findById(@PathVariable Integer id,
                      @RequestHeader("X-Token") String token);
}

Controller裏的方法也需要使用這個註解來從header中獲取Token，然後傳遞給Feign。如下：

@RestController
@RequiredArgsConstructor
public class TestController {

    private final OrderCenterService orderCenterService;

    @GetMapping("/{id}")
    public OrderDTO findById(@PathVariable("id") Integer id,
                            @RequestHeader("X-Token") String token) {
        return orderCenterService.findById(id, token);
    }
}

從上面這個例子可以看出，使用@RequestHeader註解的優點就是簡單直觀，而缺點也很明顯。當只有一兩個接口需要傳遞Token時，這種方式還是可行的，但如果有很多個遠程接口需要傳遞Token的話，那麼每個方法都得加上這個註解，顯然會增加很多重複的工作。

所以第二種傳遞Token的方式更爲通用，這種方式是通過實現一個Feign的請求攔截器，然後在攔截器中獲取當前客戶端請求所攜帶的Token並添加到Feign的請求header中，以此實現Token的傳遞。如下示例：

package com.zj.node.contentcenter.feignclient.interceptor;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * 請求攔截器，實現在服務間傳遞Token
 *
 * @author 01
 * @date 2019-09-08
 **/
public class TokenRelayRequestInterceptor implements RequestInterceptor {

    private static final String TOKEN_NAME = "X-Token";

    @Override
    public void apply(RequestTemplate requestTemplate) {
        // 獲取當前的request對象
        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 從header中獲取Token
        String token = request.getHeader(TOKEN_NAME);

        // 傳遞token
        requestTemplate.header(TOKEN_NAME,token);
    }
}

然後需要在配置文件中，配置該請求攔截器的包名路徑，不然不會生效。如下：

# 定義feign相關配置
feign:
  client:
    config:
      # default即表示爲全局配置
      default:
        requestInterceptor:
          - com.zj.node.contentcenter.feignclient.interceptor.TokenRelayRequestInterceptor

RestTemplate實現Token傳遞

除了Feign以外，部分情況下有可能會使用RestTemplate來請求其他服務的接口，所以本小節也介紹一下，在使用RestTemplate的情況下如何實現Token的傳遞。

RestTemplate也有兩種方式可以實現Token的傳遞，第一種方式是請求時使用exchange()方法，因爲該方法可以接收header。如下示例：

@RestController
@RequiredArgsConstructor
public class TestController {

    private final RestTemplate restTemplate;

    @GetMapping("/{id}")
    public OrderDTO findById(@PathVariable("id") Integer id,
                            @RequestHeader("X-Token") String token) {
        // 傳遞token                    
        HttpHeaders headers = new HttpHeaders();
        headers.add("X-Token", token);

        return restTemplate.exchange(
                "http://order-center/orders/{id}",
                HttpMethod.GET,
                new HttpEntity<>(headers),
                OrderDTO.class,
                id).getBody();
    }
}

另一種則是實現ClientHttpRequestInterceptor接口，該接口是RestTemplate的攔截器接口，與Feign的攔截器類似，都是用來實現通用邏輯的。具體代碼如下：

public class TokenRelayRequestInterceptor implements ClientHttpRequestInterceptor {

    private static final String TOKEN_NAME = "X-Token";

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body,
                                        ClientHttpRequestExecution execution) throws IOException {
        // 獲取當前的request對象
        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        HttpServletRequest servletRequest = attributes.getRequest();
        // 從header中獲取Token
        String token = servletRequest.getHeader(TOKEN_NAME);

        // 傳遞Token
        request.getHeaders().add(TOKEN_NAME,token);
        return execution.execute(request, body);
    }
}

最後需要將實現的攔截器註冊到RestTemplate中讓其生效，代碼如下：

@Configuration
public class BeanConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setInterceptors(Collections.singletonList(
                new TokenRelayRequestInterceptor()
        ));

        return restTemplate;
    }
}

AOP實現用戶權限驗證

在第一小節中我們介紹瞭如何使用AOP實現登錄態檢查，除此之外某些受保護的資源可能需要用戶擁有特定的權限才能夠訪問，那麼我們就得在該資源被訪問之前做權限校驗。權限校驗功能同樣也可以使用過濾器、攔截器或AOP來實現，和之前一樣本小節採用AOP作爲示例。

這裏也不做太複雜的校驗邏輯，主要是判斷用戶是否是某個角色即可。所以首先定義一個註解，該註解有一個value，用於標識受保護的資源需要用戶爲哪個角色才允許訪問。代碼如下：

package com.zj.node.usercenter.auth;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * 被該註解標記的方法都需要檢查用戶權限
 *
 * @author 01
 * @date 2019-09-08
 **/
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckAuthorization {

    /**
     * 允許訪問的角色名稱
     */
    String value();
}

然後定義一個切面，用於實現具體的權限校驗邏輯。代碼如下：

package com.zj.node.usercenter.auth;

import com.zj.node.usercenter.util.JwtOperator;
import io.jsonwebtoken.Claims;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.BooleanUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * 權限驗證切面類
 *
 * @author 01
 * @date 2019-09-08
 **/
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class AuthAspect {

    private static final String TOKEN_NAME = "X-Token";

    private final JwtOperator jwtOperator;

    /**
     * 在執行@CheckAuthorization註解標識的方法之前都會先執行此方法
     */
    @Around("@annotation(com.zj.node.usercenter.auth.CheckAuthorization)")
    public Object checkAuth(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取request對象
        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 從header中獲取Token
        String token = request.getHeader(TOKEN_NAME);

        // 校驗Token是否合法
        Boolean isValid = jwtOperator.validateToken(token);
        if (BooleanUtils.isFalse(isValid)) {
            log.warn("登錄態校驗不通過，無效的Token：{}", token);
            // 拋出自定義異常
            throw new SecurityException("Token不合法！");
        }

        Claims claims = jwtOperator.getClaimsFromToken(token);
        String role = (String) claims.get("role");
        log.info("登錄態校驗通過，用戶名：{}", claims.get("userName"));

        // 驗證用戶角色名稱是否與受保護資源所定義的角色名稱匹配
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CheckAuthorization annotation = signature.getMethod()
                .getAnnotation(CheckAuthorization.class);
        if (!annotation.value().equals(role)) {
            log.warn("權限校驗不通過！當前用戶角色：{} 允許訪問的用戶角色：{}",
                    role, annotation.value());
            // 拋出自定義異常
            throw new SecurityException("權限校驗不通過，無權訪問該資源！");
        }

        log.info("權限驗證通過");
        // 設置用戶信息到request裏
        request.setAttribute("id", claims.get("id"));
        request.setAttribute("userName", claims.get("userName"));
        request.setAttribute("role", claims.get("role"));

        return joinPoint.proceed();
    }
}

使用的時候只需要加上該註解並且設置角色名稱即可，如下示例：

/**
 * 需要校驗登錄態及權限後才能訪問的資源
 */
@GetMapping("/{id}")
@CheckAuthorization("admin")
public User findById(@PathVariable Integer id) {
    log.info("get request. id is {}", id);
    return userService.findById(id);
}

微服務的用戶認證與授權雜談（下）

AOP實現登錄狀態檢查

Feign實現Token傳遞

RestTemplate實現Token傳遞

AOP實現用戶權限驗證

如何使用 JS 判斷用戶是否處於活躍狀態

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

❤️‍🔥 Solon Cloud Event 新的事務特性與應用

Kafka核心API——Consumer消費者

Kafka核心API——Stream API

Kafka核心API——AdminClient API

Kafka的安裝與配置

CentOS8更換yum源後出現同步倉庫緩存失敗的問題

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結