spring boot HandlerInterceptor requestbody

可以回答这个问题。spring boot HandlerInterceptor 是一个拦截器，可以在请求处理前和处理后进行一些操作，例如记录日志、鉴权、修改请求参数等。而 requestbody 是一个注解，用于将请求体中的数据绑定到方法参数上。在拦截器中使用 requestbody 可以对请求体进行一些处理，例如解密、验签等。

相关问题

spring boot HandlerInterceptor 校验token

以下是使用Spring Boot HandlerInterceptor校验Token的步骤：

1.创建一个TokenInterceptor类，实现HandlerInterceptor接口，并在preHandle方法中进行Token校验。

public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从请求头中获取Token
        String token = request.getHeader("Token");
        if (token == null || token.isEmpty()) {
            // 如果Token为空，返回401 Unauthorized
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        } else {
            // 校验Token是否有效，这里只是简单判断Token是否为123456
            if (!token.equals("123456")) {
                // 如果Token无效，返回403 Forbidden
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                return false;
            }
        }
        return true;
    }
}

2.在Spring Boot的配置类中注册TokenInterceptor。

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor()).addPathPatterns("/**");
    }
}

3.在Controller中使用@RequestBody注解获取请求体中的JSON数据，并使用@Valid注解和自定义的校验注解对参数进行校验。

@RestController
public class MyController {
    @PostMapping("/test")
    public String test(@RequestBody @Valid MyRequest request) {
        // 处理请求
        return "success";
    }
}

4.定义一个MyRequest类，用于接收请求体中的JSON数据，并在其中定义需要校验的参数和校验注解。

public class MyRequest {
    @NotNull(message = "参数name不能为空")
    private String name;
    @Min(value = 1, message = "参数age必须大于等于1")
    private int age;

    // 省略getter和setter方法
}

spring boot controller入参body统一解密的实现方式有哪些

在Spring Boot中，可以通过自定义拦截器或注解来实现Controller入参Body统一解密的功能。下面是两种实现方式：

1. 自定义拦截器

自定义一个拦截器，通过拦截请求，在进入Controller方法之前对RequestBody进行解密，然后再将解密后的参数传递给Controller方法处理。

示例代码：

public class DecryptRequestBodyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            if (method.isAnnotationPresent(DecryptRequestBody.class)) {
                String requestBody = request.getReader().lines().collect(Collectors.joining(System.lineSeparator()));
                String decryptedRequestBody = decrypt(requestBody); // 解密RequestBody
                request.setAttribute("decryptedRequestBody", decryptedRequestBody); // 将解密后的参数放入Request中
            }
        }
        return true;
    }
}

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

@RestController
public class ExampleController {
    @PostMapping("/example")
    @DecryptRequestBody // 标注需要进行解密的方法
    public String example(@RequestBody String requestBody, HttpServletRequest request) {
        String decryptedRequestBody = (String) request.getAttribute("decryptedRequestBody"); // 从Request中获取解密后的参数
        return "Decrypted RequestBody: " + decryptedRequestBody;
    }
}

2. 自定义注解

自定义一个注解，标注需要进行解密的Controller方法，在进入Controller方法之前对注解标注的RequestBody进行解密，然后再将解密后的参数传递给Controller方法处理。

示例代码：

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

@Aspect
@Component
public class DecryptRequestBodyAspect {
    @Autowired
    private ObjectMapper objectMapper;

    @Around("@annotation(cn.example.annotation.DecryptRequestBody)")
    public Object decryptRequestBody(ProceedingJoinPoint pjp) throws Throwable {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        String requestBody = request.getReader().lines().collect(Collectors.joining(System.lineSeparator()));
        String decryptedRequestBody = decrypt(requestBody); // 解密RequestBody
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof String && AnnotationUtils.findAnnotation(pjp.getSignature().getDeclaringType().getDeclaredMethod(pjp.getSignature().getName(), String.class).getParameterAnnotations()[i], RequestBody.class) != null) {
                args[i] = objectMapper.readValue(decryptedRequestBody, pjp.getSignature().getParameterTypes()[i]); // 将解密后的参数转换为Controller方法参数类型
            }
        }
        return pjp.proceed(args);
    }
}

@RestController
public class ExampleController {
    @PostMapping("/example")
    @DecryptRequestBody // 标注需要进行解密的方法
    public String example(@RequestBody ExampleRequest request) {
        return "Decrypted RequestBody: " + request.getContent();
    }
}

public class ExampleRequest {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

以上两种实现方式都可以实现Controller入参Body统一解密的功能，具体选择哪种实现方式取决于实际需求。