使用AOP技術(shù)實現(xiàn)Java通用接口驗簽工具

一、背景

在給第三方提供接口時，我們需要對接口進行驗簽。具體來說，當外部系統(tǒng)調(diào)用我們的接口時，請求中需要攜帶一個簽名，我們接收到請求后，會解析數(shù)據(jù)并校驗簽名是否正確，以確保請求的合法性和安全性。

為了在不同項目中方便地使用這一功能，我們將簽名校驗規(guī)則封裝成一個工具包。使用方只需通過簡單的注解即可輕松集成驗簽功能，無需重復(fù)編寫驗簽邏輯，從而提高開發(fā)效率并確保一致性。

二、實現(xiàn)原理

使用AOP來攔截方法
獲取參數(shù)值進行組裝、校驗簽名是否一致

三、設(shè)計思路

通過倆個注解進行標記所需要進行驗簽的方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SignatureChecker {

    // 服務(wù)Code
    String serviceCode() default SignatureConst.EMPTY_STR;

    // 簽名生成密鑰
    String secretKey() default SignatureConst.EMPTY_STR;

    // 簽名過期時間，單位為分鐘
    int expireMinutes() default -1;

    // 默認為true，表示需要驗證簽名
    boolean required() default true;

    // 返回值類型
    String returnType() default SignatureConst.DEFAULT_RETURN_TYPE;

}

serviceCode：服務(wù)編碼，進行區(qū)分不同的服務(wù)/業(yè)務(wù)
secretKey：雙方約定好的密鑰，進行生成簽名，可以寫在配置文件中。
expireMinutes：標識簽名有效時長，默認5分鐘，可以配置文件中進行全局修改。

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface SignatureParam {

    // 0:標識serviceCode 1:標識請求參數(shù)
    SignatureParamTypeEnum type() default SignatureParamTypeEnum.PARAMS;

    String requestIdField() default SignatureConst.EMPTY_STR;

    String timestampField() default SignatureConst.EMPTY_STR;

    String signatureField() default SignatureConst.EMPTY_STR;

}

對于不同的請求實體，可能對應(yīng)的字段名不相同，所以我們需要使用一個注解進行標注當前實體驗簽字段的名稱。

當簽名字段發(fā)生變化時，可以使用requestIdField、timestampField、signatureField 字段進行指定。

四、代碼

4.1 代碼結(jié)構(gòu)

4.2 詳細代碼

4.2.1 SignatureChecker.class

import org.tao.consts.SignatureConst;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SignatureChecker {

    // 服務(wù)Code
    String serviceCode() default SignatureConst.EMPTY_STR;

    // 簽名生成密鑰
    String secretKey() default SignatureConst.EMPTY_STR;

    // 簽名過期時間，單位為分鐘
    int expireMinutes() default -1;

    // 默認為true，表示需要驗證簽名
    boolean required() default true;

    // 返回值類型
    String returnType() default SignatureConst.DEFAULT_RETURN_TYPE;

}

4.2.2 SignatureParam.class

import org.tao.consts.SignatureConst;
import org.tao.enums.SignatureParamTypeEnum;

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

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface SignatureParam {

    // 0:標識serviceCode 1:標識請求參數(shù)
    SignatureParamTypeEnum type() default SignatureParamTypeEnum.PARAMS;

    String requestIdField() default SignatureConst.EMPTY_STR;

    String timestampField() default SignatureConst.EMPTY_STR;

    String signatureField() default SignatureConst.EMPTY_STR;

}

4.2.3 SignatureAspect.class


import com.alibaba.fastjson2.JSON;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.tao.anno.SignatureChecker;
import org.tao.anno.SignatureParam;
import org.tao.config.SignatureProperties;
import org.tao.consts.SignatureConst;
import org.tao.enums.SignatureParamTypeEnum;
import org.tao.exception.SignatureValidationException;
import org.tao.utils.SignatureUtil;

import javax.annotation.Resource;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Map;

@Aspect
@Component
public class SignatureAspect {
    private static final Logger logger = LoggerFactory.getLogger(SignatureAspect.class);

    @Resource
    private SignatureProperties signatureProperties;

    @Around("@annotation(org.tao.anno.SignatureChecker) " +
            "&& (@annotation(org.springframework.web.bind.annotation.PostMapping) || @annotation(org.springframework.web.bind.annotation.RequestMapping))")
    public Object validateSignature(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        Map<String, Object> paramMap = null;
        String serviceCode = null;
        Object[] args = joinPoint.getArgs();
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        SignatureChecker signatureChecker = method.getAnnotation(SignatureChecker.class);
        if (signatureChecker != null && signatureChecker.required()) {
            SignatureParam signatureParam = null;
            // 遍歷參數(shù)注解，找到被 @SignatureParam 注解修飾的參數(shù)
            for (int i = 0; i < parameterAnnotations.length; i++) {
                for (Annotation anno : parameterAnnotations[i]) {
                    if (anno instanceof SignatureParam) {
                        signatureParam = (SignatureParam) anno;
                        Object paramValue = args[i];
                        if (signatureParam.type() == SignatureParamTypeEnum.PARAMS) {
                            try {
                                paramMap = JSON.parseObject(JSON.toJSONString(paramValue), Map.class);
                            } catch (Exception e) {
                                logger.error("[簽名校驗] 失敗，請檢查 params 參數(shù)是否正確, paramsValue => {}, message => {}", JSON.toJSONString(paramValue), e.getMessage());
                            }
                        } else if (signatureParam.type() == SignatureParamTypeEnum.SERVICE_CODE) {
                            if (paramValue instanceof String) {
                                serviceCode = paramValue.toString();
                            } else {
                                logger.error("[簽名校驗] 失敗，請檢查 serviceCode 參數(shù)是否正確, serviceCode => {}", JSON.toJSONString(paramValue));
                            }
                        } else {
                            throw new SignatureValidationException(SignatureConst.DEFAULT_RETURN_TYPE, "參數(shù)類型錯誤，請檢查！");
                        }
                    }
                }
            }

            try {
                validateSignature(signatureChecker, signatureParam, paramMap, serviceCode);
            } catch (SignatureValidationException e) {
                logger.warn("[簽名校驗] 校驗失敗，paramMap => {}, message => {}", JSON.toJSONString(paramMap), e.getMessage());
                throw e;
            } catch (Exception e){
                logger.error("[簽名校驗] 校驗失敗，paramMap => {}, message => {}", JSON.toJSONString(paramMap), e.getMessage());
                throw new SignatureValidationException(SignatureConst.DEFAULT_RETURN_TYPE, "系統(tǒng)異常，請稍后重試！");
            }
        }

        // 繼續(xù)執(zhí)行原方法
        return joinPoint.proceed();
    }

    private void validateSignature(SignatureChecker checker, SignatureParam signatureParam, Map<String, Object> paramMap, String serviceCode) throws SignatureValidationException {
        // 獲取服務(wù)編碼，如果 SignatureChecker 指定，選擇 SignatureChecker 的值，否則選擇 signatureParam 標記的值
        String servicedCodeNew = StringUtils.isEmpty(checker.serviceCode()) ? serviceCode : checker.serviceCode();
        if (StringUtils.isEmpty(servicedCodeNew)) {
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 缺失 serviceCode，請配置！");
        }

        // 獲取密鑰 如果 SignatureChecker 指定，選擇 SignatureChecker 的值，否則選擇 signatureProperties 配置的值
        String secretKey = StringUtils.isEmpty(checker.secretKey()) ? signatureProperties.getSecretKeys().get(servicedCodeNew) : checker.secretKey();
        if (StringUtils.isEmpty(secretKey)) {
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 缺失 secretKey，請配置！");
        }

        // 獲取參數(shù)字段 如果 signatureParam 指定，選擇 signatureParam 的值，否則選擇 signatureProperties 配置的值
        String signatureField = StringUtils.isEmpty(signatureParam.signatureField()) ? signatureProperties.getSignatureField() : signatureParam.signatureField();
        String requestIdField = StringUtils.isEmpty(signatureParam.requestIdField()) ? signatureProperties.getRequestIdField() : signatureParam.requestIdField();
        String timestampField = StringUtils.isEmpty(signatureParam.timestampField()) ? signatureProperties.getTimestampField() : signatureParam.timestampField();

        // 獲取實際請求參數(shù)數(shù)據(jù)
        String requestId = paramMap.get(requestIdField) == null ? null : paramMap.get(requestIdField).toString();
        Long timestamp = paramMap.get(timestampField) == null ? null : Long.parseLong(paramMap.get(timestampField).toString());
        String signature = paramMap.get(signatureField) == null ? null : paramMap.get(signatureField).toString();
        if (StringUtils.isEmpty(requestId) || StringUtils.isEmpty(signature) || StringUtils.isEmpty(timestamp)) {
            logger.warn("[驗簽失敗] 缺失鑒權(quán)參數(shù)，請檢查！requestId => {}, signature => {}, timestamp => {}", requestId, signature, timestamp);
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 缺失鑒權(quán)參數(shù)，請檢查！");
        }

        // 校驗時間戳
        validateTimestamp(checker, timestamp);

        // 校驗簽名
        if (!SignatureUtil.verifySignature(requestId + timestamp, secretKey, signature)) {
            throw new SignatureValidationException(checker.returnType(), "簽名校驗不通過！");
        }
    }

    private void validateTimestamp(SignatureChecker checker, long timestamp) throws SignatureValidationException {
        // 如果是-1，則使用配置文件中的默認值
        long expireMinutes = checker.expireMinutes() == -1 ? signatureProperties.getExpireMinutes() : checker.expireMinutes();
        // 如果是0，則代表永久有效，不進行時間判斷
        if (expireMinutes == 0) {
            return;
        } else if (expireMinutes <= 0) {
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 過期時間配置無效，請檢查！");
        }

        long currentTime = System.currentTimeMillis();
        if (timestamp > currentTime + 5 * 60 * 1000) {
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 調(diào)用端時間與服務(wù)器時間未同步，請檢查！");
        } else if (currentTime - timestamp > (long) expireMinutes * 60 * 1000) {
            throw new SignatureValidationException(checker.returnType(), "[驗簽失敗] 請求已過期，請重新請求！");
        }
    }
}

4.2.4 SignatureAutoConfiguration.class

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.tao.aspect.SignatureAspect;


/**
 * @author: handsometaoa
 * @description
 * @date: 2025/3/29 11:00
 */


@Configuration
@EnableConfigurationProperties(SignatureProperties.class)
@ComponentScan(basePackages = {"org.tao"})
public class SignatureAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public SignatureAspect signatureAspect() {
        return new SignatureAspect();
    }


}

4.2.5 SignatureProperties.class

import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.HashMap;
import java.util.Map;

@ConfigurationProperties(prefix = "signature")
public class SignatureProperties {

    private String requestIdField = "requestId";
    private String timestampField = "timestamp";
    private String signatureField = "signature";
    private Integer expireMinutes = 5;

    private Map<String, String> secretKeys = new HashMap<>();
    private Map<String, String> returnJsons = new HashMap<>();

    public Map<String, String> getSecretKeys() {
        return secretKeys;
    }

    public void setSecretKeys(Map<String, String> secretKeys) {
        this.secretKeys = secretKeys;
    }

    public Integer getExpireMinutes() {
        return expireMinutes;
    }

    public void setExpireMinutes(Integer expireMinutes) {
        this.expireMinutes = expireMinutes;
    }

    public String getRequestIdField() {
        return requestIdField;
    }

    public void setRequestIdField(String requestIdField) {
        this.requestIdField = requestIdField;
    }

    public String getSignatureField() {
        return signatureField;
    }

    public void setSignatureField(String signatureField) {
        this.signatureField = signatureField;
    }

    public String getTimestampField() {
        return timestampField;
    }

    public void setTimestampField(String timestampField) {
        this.timestampField = timestampField;
    }

    public Map<String, String> getReturnJsons() {
        return returnJsons;
    }

    public void setReturnJsons(Map<String, String> returnJsons) {
        this.returnJsons = returnJsons;
    }
}

4.2.6 SignatureConst.class

public class SignatureConst {

    public static final String DEFAULT_RETURN_TYPE = "default";

    public static final String EMPTY_STR = "";

}

4.2.7 SignatureParamTypeEnum.class

public enum SignatureParamTypeEnum {

    SERVICE_CODE(1, "服務(wù)編碼"),
    PARAMS(2, "參數(shù)");

    private Integer code;
    private String desc;

    SignatureParamTypeEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public Integer getCode() {
        return code;
    }


}

4.2.8 GlobalExceptionHandler

import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.tao.config.SignatureProperties;
import org.tao.consts.SignatureConst;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    @Resource
    private SignatureProperties signatureProperties;

    @ExceptionHandler(SignatureValidationException.class)
    public ResponseEntity<Map<String, Object>> handleSignatureValidationException(SignatureValidationException ex) {
        Map<String, Object> map = new HashMap<>();
        map.put("code", 500);
        map.put("message", ex.getMessage());
        if (ex.getReturnType() != null && !ex.getReturnType().equals(SignatureConst.DEFAULT_RETURN_TYPE)) {
            String responseStr = signatureProperties.getReturnJsons().get(ex.getReturnType());
            if (StringUtils.isEmpty(responseStr)) {
                log.error("[全局異常處理] 返回json配置錯誤，請檢查配置！");
            } else {
                responseStr = responseStr.replace("${message}", ex.getMessage());
            }
            map = JSON.parseObject(responseStr, Map.class);
        }
        return new ResponseEntity<>(map, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

4.2.9 SignatureValidationException.class


import org.tao.consts.SignatureConst;

public class SignatureValidationException extends RuntimeException {

    private String returnType = SignatureConst.DEFAULT_RETURN_TYPE;

    public SignatureValidationException(String returnType, String message) {
        super(message);
        this.returnType = returnType;
    }

    public String getReturnType() {
        return returnType;
    }
}

4.2.10 AnnotationValidationProcessor.class

import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.tao.anno.SignatureChecker;
import org.tao.anno.SignatureParam;
import org.tao.config.SignatureProperties;
import org.tao.consts.SignatureConst;
import org.tao.enums.SignatureParamTypeEnum;
import org.tao.exception.GlobalExceptionHandler;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Map;

@Component
public class AnnotationValidationProcessor implements BeanPostProcessor {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @Resource
    private SignatureProperties signatureProperties;

    @PostConstruct
    public void preCheck() {
        Map<String, String> returnJsons = signatureProperties.getReturnJsons();
        if (returnJsons != null && !returnJsons.isEmpty()) {
            returnJsons.forEach((key, value) -> {
                if (!JSON.isValidObject(value)) {
                    log.warn("[驗簽配置校驗] 返回類型 json 字符串配置錯誤，value => {}", value);
                    throw new IllegalStateException("[驗簽配置校驗] 返回類型 json 字符串配置錯誤，請檢查配置！");
                }
            });
        }
    }


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Class<?> clazz = bean.getClass();
        for (Method method : clazz.getDeclaredMethods()) {
            // 檢查方法是否帶有 @SignatureChecker
            if (method.isAnnotationPresent(SignatureChecker.class)) {
                SignatureChecker annotation = method.getAnnotation(SignatureChecker.class);

                if (!StringUtils.isEmpty(annotation.serviceCode()) && StringUtils.isEmpty(annotation.secretKey())) {
                    if (!signatureProperties.getSecretKeys().containsKey(annotation.serviceCode())) {
                        log.warn("[驗簽配置校驗] 配置缺失服務(wù)編碼對應(yīng)的密鑰，serviceCode => {}", annotation.serviceCode());
                        throw new IllegalStateException("[驗簽配置校驗] 配置缺失服務(wù)編碼對應(yīng)的密鑰，請檢查配置！");
                    }
                }
                if (!annotation.returnType().equals(SignatureConst.DEFAULT_RETURN_TYPE)) {
                    if (!signatureProperties.getReturnJsons().containsKey(annotation.returnType())) {
                        log.warn("[驗簽配置校驗] 配置缺失返回類型 JSON 字符串，returnType => {}", annotation.returnType());
                        throw new IllegalStateException("[驗簽配置校驗] 配置缺失返回類型 JSON 字符串，請檢查配置！");
                    }
                }

                // 檢查是否同時帶有 @PostMapping 或 @RequestMapping
                if (!method.isAnnotationPresent(PostMapping.class) && !method.isAnnotationPresent(RequestMapping.class)) {
                    throw new IllegalStateException("方法 " + method.getName() + " 必須同時帶有 @PostMapping 或 @RequestMapping 注解");
                }
                // 檢查方法參數(shù)
                validateMethodParameters(method);
            }
        }
        return bean;
    }

    private void validateMethodParameters(Method method) {
        // 這里可以根據(jù)業(yè)務(wù)需求檢查方法的參數(shù)
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length == 0) {
            throw new IllegalStateException("[驗簽配置校驗] 方法 " + method.getClass().getName() + "." + method.getName() + " 必須至少有一個參數(shù)");
        }
        // 其他校驗邏輯
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (int i = 0; i < parameterAnnotations.length; i++) {
            for (Annotation anno : parameterAnnotations[i]) {
                if (anno instanceof SignatureParam) {
                    SignatureParam signatureParam = (SignatureParam) anno;
                    Class<?> aClass = parameterTypes[i];
                    if (signatureParam.type() == SignatureParamTypeEnum.PARAMS) {
                        if (isPrimitiveType(aClass)) {
                            throw new IllegalStateException("[驗簽配置校驗] " + method.getName() + " 方法 params 參數(shù)" + " 必須是對象類型");
                        }
                    } else if (signatureParam.type() == SignatureParamTypeEnum.SERVICE_CODE) {
                        if (aClass != String.class) {
                            throw new IllegalStateException("[驗簽配置校驗] " + method.getName() + " 方法 serviceCode 參數(shù)" + " 必須是String類型");
                        }
                    } else {
                        throw new IllegalStateException("[驗簽配置校驗] " + method.getName() + " 暫未適配類型");
                    }
                }
            }
        }
    }

    private boolean isPrimitiveType(Class<?> clazz) {
        return clazz.isPrimitive() || clazz == Integer.class || clazz == Boolean.class ||
                clazz == Character.class || clazz == Byte.class || clazz == Short.class ||
                clazz == Long.class || clazz == Float.class || clazz == Double.class;
    }

}

4.2.11 SignatureUtil.class



import org.springframework.util.DigestUtils;

/**
 * @author: handsometaoa
 * @description
 * @date: 2025/3/29 11:00
 */
public class SignatureUtil {

    /**
     * 校驗簽名是否正確
     *
     * @param params    請求參數(shù)
     * @param sign      客戶端傳遞的簽名
     * @param secretKey 密鑰
     * @return 是否校驗通過
     */
    public static boolean verifySignature(String params, String secretKey, String sign) {
        String serverSign = generateSignature(params, secretKey);
        return serverSign.equals(sign);
    }


    /**
     * 生成簽名
     *
     * @param requestId 請求id
     * @param timestamp 時間戳
     * @param secretKey 密鑰
     * @return 生成的簽名
     */
    public static String generateSignature(String requestId, String timestamp, String secretKey) {
        String rawData = requestId + timestamp + secretKey;
        return DigestUtils.md5DigestAsHex(rawData.getBytes());
    }



    private static String generateSignature(String params, String secretKey) {
        String rawData = params + secretKey;
        return DigestUtils.md5DigestAsHex(rawData.getBytes());
    }


}

4.2.12 spring.factories.class

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.tao.config.SignatureAutoConfiguration

4.2.13 pom.xml

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
      <version>2.1.3.RELEASE</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-autoconfigure</artifactId>
      <version>2.1.3.RELEASE</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.1.3.RELEASE</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>com.alibaba.fastjson2</groupId>
      <artifactId>fastjson2</artifactId>
      <version>2.0.31</version>
      <optional>true</optional>
    </dependency>
  </dependencies>

五、使用方式

5.1 集成方式（倆種方式）

打成 jar 包引入依賴
直接將代碼拷進自己項目

5.2 使用說明

在方法上添加 @SignatureChecker 注解，包含密鑰的參數(shù)前添加 @SignatureParam 注解；舉例：假設(shè)需要給XX業(yè)務(wù)進行驗簽，約定密鑰為XXX，請求參數(shù)分別為 request_id、timeStamp、signature

@PostMapping("test")
@SignatureChecker(serviceserCode = "XX", secretKey = "XXX")
public String test(@RequestBody @SignatureParam(requestIdField = "request_id", timestampField = "timeStamp") Request request) {
    return "test";
}

基于注解值 > 配置值 > 默認值（約定大于配置）

serviceCode ： SignatureChecker 指定 serviceserCode【此方式只能固定一個serviceCode】 > SignatureParam(type = 0) 標注【此方式可標注到 String 字段上，更加通用】
密鑰 secretKey : 注解(secretKey) > 配置值（signature.secretKeys 中定義的）
有效期 expireMinutes：注解（expireMinutes）> 配置值（signature.expireMinutes）> 默認值（5）
驗簽字段：注解（requestIdField、timestampField、signatureField）> 配置值（signature.requestIdField) > 默認值（requestId、timestamp、signature）

請求接口

六、最后

當然代碼還是有很多不足的地方，僅供學(xué)習(xí)參考。
源碼：https://github.com/handsometaoa/signutare-kit

posted @ 2025-03-29 11:56 帥氣的濤啊閱讀(536) 評論(0) 收藏舉報

刷新頁面返回頂部

次日清晨醒著眼睛

我寫的代碼和詩一樣

使用AOP技術(shù)實現(xiàn)Java通用接口驗簽工具

一、背景

二、實現(xiàn)原理

三、設(shè)計思路

四、代碼

4.1 代碼結(jié)構(gòu)

4.2 詳細代碼

4.2.1 SignatureChecker.class

4.2.2 SignatureParam.class

4.2.3 SignatureAspect.class

4.2.4 SignatureAutoConfiguration.class

4.2.5 SignatureProperties.class

4.2.6 SignatureConst.class

4.2.7 SignatureParamTypeEnum.class

4.2.8 GlobalExceptionHandler

4.2.9 SignatureValidationException.class

4.2.10 AnnotationValidationProcessor.class

4.2.11 SignatureUtil.class

4.2.12 spring.factories.class

4.2.13 pom.xml

五、使用方式

5.1 集成方式（倆種方式）

5.2 使用說明

六、最后

公告

次日清晨醒著眼睛

我寫的代碼和詩一樣

使用AOP技術(shù)實現(xiàn)Java通用接口驗簽工具

一、背景

二、實現(xiàn)原理

三、設(shè)計思路

四、代碼

4.1 代碼結(jié)構(gòu)

4.2 詳細代碼

4.2.1 SignatureChecker.class

4.2.2 SignatureParam.class

4.2.3 SignatureAspect.class

4.2.4 SignatureAutoConfiguration.class

4.2.5 SignatureProperties.class

4.2.6 SignatureConst.class

4.2.7 SignatureParamTypeEnum.class

4.2.8 GlobalExceptionHandler

4.2.9 SignatureValidationException.class

4.2.10 AnnotationValidationProcessor.class

4.2.11 SignatureUtil.class

4.2.12 spring.factories.class

4.2.13 pom.xml

五、使用方式

5.1 集成方式 （倆種方式）

5.2 使用說明

六、最后

公告

5.1 集成方式（倆種方式）