使用AOP技术实现Java通用接口验签工具

原创 于 2025-04-09 16:59:49 发布
· 606 阅读 · 18 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #python #数据库

一、背景

在给第三方提供接口时，我们需要对接口进行验签。具体来说，当外部系统调用我们的接口时，请求中需要携带一个签名，我们接收到请求后，会解析数据并校验签名是否正确，以确保请求的合法性和安全性。

为了在不同项目中方便地使用这一功能，我们将签名校验规则封装成一个工具包。使用方只需通过简单的注解即可轻松集成验签功能，无需重复编写验签逻辑，从而提高开发效率并确保一致性。

二、实现原理

  1. 使用AOP来拦截方法
  2. 获取参数值进行组装、校验签名是否一致

三、设计思路

通过俩个注解进行标记所需要进行验签的方法

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

    // 服务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：服务编码，进行区分不同的服务/业务
secretKey：双方约定好的密钥，进行生成签名，可以写在配置文件中。
expireMinutes：标识签名有效时长，默认5分钟，可以配置文件中进行全局修改。

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

    // 0:标识serviceCode 1:标识请求参数
    SignatureParamTypeEnum type() default SignatureParamTypeEnum.PARAMS;

    String requestIdField() default SignatureConst.EMPTY_STR;

    String timestampField() default SignatureConst.EMPTY_STR;

    String signatureField() default SignatureConst.EMPTY_STR;

}

对于不同的请求实体，可能对应的字段名不相同，所以我们需要使用一个注解进行标注当前实体验签字段的名称。

当签名字段发生变化时，可以使用requestIdField、timestampField、signatureField 字段进行指定。

四、代码

4.1 代码结构

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 {

    // 服务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:标识请求参数
    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;
            // 遍历参数注解，找到被 @SignatureParam 注解修饰的参数
            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 参数是否正确, 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 参数是否正确, serviceCode => {}", JSON.toJSONString(paramValue));
                            }
                        } else {
                            throw new SignatureValidationException(SignatureConst.DEFAULT_RETURN_TYPE, "参数类型错误，请检查！");
                        }
                    }
                }
            }

            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, "系统异常，请稍后重试！");
            }
        }

        // 继续执行原方法
        return joinPoint.proceed();
    }

    private void validateSignature(SignatureChecker checker, SignatureParam signatureParam, Map<String, Object> paramMap, String serviceCode) throws SignatureValidationException {
        // 获取服务编码，如果 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，请配置！");
        }

        // 获取参数字段 如果 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();

        // 获取实际请求参数数据
        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("[验签失败] 缺失鉴权参数，请检查！requestId => {}, signature => {}, timestamp => {}", requestId, signature, timestamp);
            throw new SignatureValidationException(checker.returnType(), "[验签失败] 缺失鉴权参数，请检查！");
        }

        // 校验时间戳
        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(), "[验签失败] 调用端时间与服务器时间未同步，请检查！");
        } 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, "服务编码"),
    PARAMS(2, "参数");

    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("[验签配置校验] 配置缺失服务编码对应的密钥，serviceCode => {}", annotation.serviceCode());
                        throw new IllegalStateException("[验签配置校验] 配置缺失服务编码对应的密钥，请检查配置！");
                    }
                }
                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 注解");
                }
                // 检查方法参数
                validateMethodParameters(method);
            }
        }
        return bean;
    }

    private void validateMethodParameters(Method method) {
        // 这里可以根据业务需求检查方法的参数
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length == 0) {
            throw new IllegalStateException("[验签配置校验] 方法 " + method.getClass().getName() + "." + method.getName() + " 必须至少有一个参数");
        }
        // 其他校验逻辑
        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 参数" + " 必须是对象类型");
                        }
                    } else if (signatureParam.type() == SignatureParamTypeEnum.SERVICE_CODE) {
                        if (aClass != String.class) {
                            throw new IllegalStateException("[验签配置校验] " + method.getName() + " 方法 serviceCode 参数" + " 必须是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    请求参数
     * @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 集成方式 （俩种方式）

  1. 打成 jar 包引入依赖
  2. 直接将代码拷进自己项目

5.2 使用说明

  1. 在方法上添加 @SignatureChecker 注解，包含密钥的参数前添加 @SignatureParam 注解；举例：假设需要给XX业务进行验签，约定密钥为XXX，请求参数分别为 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";
}
  1. 基于 注解值 > 配置值 > 默认值 （约定大于配置）
  • 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）
  1. 请求接口

 

行业拓展

分享一个面向研发人群使用的前后端分离的低代码软件——JNPF。

基于 Java Boot/.Net Core双引擎，它适配国产化，支持主流数据库和操作系统，提供五十几种高频预制组件，内置了常用的后台管理系统使用场景和实用模版，通过简单的拖拉拽操作，开发者能够高效完成软件开发，提高开发效率，减少代码编写工作。

JNPF基于SpringBoot+Vue.js，提供了一个适合所有水平用户的低代码学习平台，无论是有经验的开发者还是编程新手，都可以在这里找到适合自己的学习路径。

此外，JNPF支持全源码交付，完全支持根据公司、项目需求、业务需求进行二次改造开发或内网部署，具备多角色门户、登录认证、组织管理、角色授权、表单设计、流程设计、页面配置、报表设计、门户配置、代码生成工具等开箱即用的在线服务。

Spring基于AspectJ实现验签切点
专注于计算机研发知识和资讯分享
04-29 238
Aspect@Component@Order(0)/*** 验签切点(完整的找到设置的文件地址)* execution：用于匹配方法执行的连接点*其中带?号的 modifiers-pattern?是可选项* ret-type-pattern,name-pattern, parameters-pattern是必选项修饰符匹配，如public 表示匹配公有方法* ret-type-pattern 返回值匹配，* 表示任何返回值，全路径的类名等类路径匹配。
java安全入门篇之接口验签(原创)
weixin_30291791的博客
03-16 415
文章大纲 一、加密与验签介绍二、接口验签实操三、项目源码下载 一、加密与验签介绍   大多数公共网络是不安全的，一切基于HTTP协议的请求/响应(Request or Response)都是可以被截获的、篡改、重放(重发)的。因此我们需要考虑以下几点内容： 防伪装攻击（案例：在公共网络环境中，第三方 有意或恶意 的调用我们的接口） ...
MD5类加密工具续（2）
ilovegreenrose的专栏
05-29 349
public static String getMD5String(String s) {   return getMD5String(s.getBytes());  }  public static String getMD5String(byte[] bytes) {   messagedigest.update(bytes);   return bufferToHex(messag
Java 接口签名(Signature)实现方案
u011997561的博客
10-29 666
1、前言 在为第三方系统提供接口的时候，肯定要考虑接口数据的安全问题，比如数据是否被篡改，数据是否已经过时，数据是否可以重复提交等问题。其中我认为最终要的还是数据是否被篡改。在此分享一下我的关于接口签名的实践方案。如果这种方案不是很好理解，请参考另一篇更简单暴力的方案 java接口签名(Signature)实现方案续 。 2、签名流程 3、签名规则 1、线下分配appid和appsecret，针对不同的调用方分配不同的appid和appsecret 2、加入timestamp（时间戳），10分钟内数据有效
Java Http接口加签、验签操作方法
09-01
下面小编就为大家带来一篇Java Http接口加签、验签操作方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
农行快e通授权 已调通使用中
06-06
1. **Java基础**：这个项目的基础是Java编程语言，开发者需要掌握包括类、对象、接口、异常处理、集合框架（如List、Set、Map）等核心概念。 2. **MVC架构**：由于描述中提到的是一个项目，很可能采用了Model-View-...
SpringBoot 接口层统一加密解密
mxt51220的博客
11-18 709
自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露在resource目录下准备一个名为spring/spring.factories的文件，以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key，自动配置类为value列表，进行注册。
JAVA面试基础 自整理
weixin_60721479的博客
01-11 753
Object类方法： clone() 创建并返回此对象的一个副体 equals(object) 比较两个对象是否相等 finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由该对象的垃圾回收器调用此方法 getClass() 返回一个class对象，经常用于java反射机制 toString() 返回该对象的字符串表示 hashCode() 获取对象的哈希值 notify() 唤醒在此对象监视器上等待的单个线程 ...
鉴权 OAuth 2.0的实现（Spring_Security_Oauth2）
qq_25156781的博客
01-28 3771
可以理解为客户端和服务器之间的一次私密谈话，在一次对话中可能会有多个请求和响应；同时要具有鉴别多个请求是来自同一个客户端的一次对话的功能；用户认证通过后，为了避免用户的每次操作都进行认证，可将用户的信息保证在会话中。会话就是系统为了保持当前用户的登录状态所提供的机制，常见的有基于session方式、基于token方式等。
API接签名验证
08-01
http Restful API接签名验证 ,防API接口进行在公网裸奔
JAVA实现RSA签名、验签
Smilelfq的专栏
09-02 3505
生成签名的时候将需要传递的参数bean通过BaseHelper.sortParamAll(bean)转成K=V&K1=V1......的形式，然后调用Rsa.sign()方法即可生成签名。验签的时候获取到传递过来的参数json串（jsonParams），同样将业务参数通过BaseHelper.sortCheckParam(jsonParams)转成K=V&K1=V1......的形式（剔除sign参数），然后调用Rsa.doCheck()方法验证签名是否通过。2、使用私钥进行签名。3、使用公钥验证签名。
Java接口sign签名和sign验签处理
最新发布
qq_44749121的博客
05-11 949
1.Java接口sign签名工具类。
最易于使用的java接口签名实现
weixin_38387358的博客
08-03 4314
最易于使用的java对外接口签名实现
java/springboot服务第三方接口安全签名(Signature)实现方案
Mervin
11-03 3866
springboot服务第三方接口安全签名(Signature)实现方案
Aop实现接口方式
06-30 3220
前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。 最终通知（Aft
接口方式实现AOP
ke7025的博客
08-10 835
实现效果请划至最后一步 1. 实现核心 需要将DefaultPointcutAdvisor注入spring容器，怎么将bean优雅的注入spring下面会详细说明。 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(); pointcut.setExpression(this.expression()); DefaultPointcutAdvisor bean = new DefaultPointcutAdvisor();
轻松实现开放接口的签名和验签
竹林幽深
12-01 1879
开放接口是指不需要登录凭证就允许被第三方系统调用的接口，这个时候肯定要考虑接口数据的安全性问题，比如数据是否被篡改，数据是否已经过时，数据是否可以重复提交等问题，为了防止开放接口被恶意调用，开放接口一般都需要验签才能被调用。私钥和公钥直接保存在文件中spring:redis:port: 6379signature:key-pair:# 调用方IDtest-1:# 算法# 私钥# 公钥# 生效时间(分钟)自定义验签注解，控制哪些接口需要验签//允许重复请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值