springboot 中拦截器与过滤器的区别是什么，两种方式的使

springboot 中拦截器与过滤器的区别是什么，两种方式的使用场景分别是什么？

拦截器（Interceptor）和过滤器（Filter）是Spring Boot中常用的两种请求处理机制，它们有以下区别和使用场景：

区别：

1. 拦截器是基于Java反射机制实现的，而过滤器是基于Servlet规范实现的。
2. 拦截器只能对Spring MVC的请求进行拦截处理，而过滤器可以对所有的请求进行拦截处理，包括静态资源请求。
3. 拦截器可以访问Spring MVC的上下文（如HandlerMethod等），而过滤器无法直接访问。

使用场景：

1. 拦截器适用于对特定的Controller请求进行预处理、后处理、日志记录等操作，如权限验证、日志记录等。
2. 过滤器适用于对所有的请求进行统一的处理，如字符编码转换、请求参数过滤、请求响应压缩等。

总结：

• 如果需要对特定的Controller请求进行处理，可以使用拦截器。
• 如果需要对所有的请求进行统一处理，包括静态资源请求，可以使用过滤器。

想要对 post 请求中的 request body 参数进行统一解密，然后再继续调用接口，这个是使用拦截器还是过滤器？

对于对 POST 请求中的请求体参数进行解密的需求，可以使用过滤器来实现。

过滤器可以在请求到达控制器之前拦截请求，并对请求进行处理。在过滤器中，您可以获取请求的原始数据，包括请求体参数，并对其进行解密操作。然后，您可以将解密后的参数设置回请求中，再继续传递给下一个处理器（如控制器）。

使用过滤器的好处是，它可以对所有的请求进行统一处理，而不仅限于特定的控制器。这样可以确保所有的 POST 请求都经过解密处理，提高代码的可维护性和复用性。

因此，建议使用过滤器来对 POST 请求中的请求体参数进行解密操作。

springboot 过滤器 AES 解密示例

在 Spring Boot 中，可以通过实现 javax.servlet.Filter 接口来创建过滤器，并将其注册到应用程序中。下面是一个使用过滤器实现 AES 解密逻辑的示例代码：

import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
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.Base64;

@Component
public class AesDecryptionFilter extends OncePerRequestFilter {

    private static final String SECRET_KEY = "mysecretkey12345";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String encryptedValue = request.getParameter("data");
        if (encryptedValue != null) {
            try {
                String decryptedValue = decrypt(encryptedValue, SECRET_KEY);
                request.setAttribute("decryptedData", decryptedValue);
            } catch (Exception e) {
                // 解密失败，可以根据实际情况进行处理
            }
        }
        filterChain.doFilter(request, response);
    }

    private String decrypt(String encryptedValue, String secretKey) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(secretKey.getBytes(StandardCharsets.UTF_8));
        SecretKeySpec keySpec = new SecretKeySpec(decodedKey, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        byte[] decodedValue = Base64.getDecoder().decode(encryptedValue.getBytes(StandardCharsets.UTF_8));
        byte[] decryptedValue = cipher.doFinal(decodedValue);
        return new String(decryptedValue, StandardCharsets.UTF_8);
    }
}

上面的示例中，AesDecryptionFilter 类继承了 OncePerRequestFilter 类，这意味着过滤器只会在每个请求中执行一次。在 doFilterInternal 方法中，我们首先检查请求中是否包含名为 data 的参数，如果存在，则进行解密并将解密后的值设置为请求属性 decryptedData。最后，我们使用 filterChain.doFilter(request, response) 调用过滤器链中的下一个过滤器。

在解密方法中，我们使用 Base64 解码密钥和加密数据，并使用 Cipher 类执行 AES 解密操作。请注意，此示例假定使用的是 AES 的 ECB 模式和 PKCS5 填充。在实际使用中，可能需要根据具体情况进行调整，例如选择不同的模式（如 CBC）和填充方式。

最后，在应用程序中注册过滤器。可以通过在 Spring Boot 应用程序的配置类中添加以下代码来完成此操作：

@Configuration
public class AppConfig {

    @Autowired
    private AesDecryptionFilter aesDecryptionFilter;

    @Bean
    public FilterRegistrationBean<AesDecryptionFilter> loggingFilter() {
        FilterRegistrationBean<AesDecryptionFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(aesDecryptionFilter);
        registrationBean.addUrlPatterns("/api/*"); // 指定要应用过滤器的 URL 模式
        return registrationBean;
    }
}

上面的示例中，我们创建了一个 FilterRegistrationBean 对象，并将其设置为 AesDecryptionFilter 的实例。然后，我们使用 addUrlPatterns 方法指定要应用过滤器的 URL 模式。在这个例子中，我们假设所有 API 请求都以 /api/ 开头。

springboot 过滤器对 post body 参数解密示例

@Component
public class AesDecryptionFilter extends OncePerRequestFilter {

    private static final String SECRET_KEY =  "mfsecretkey14523";
    private static final String INIT_VECTOR = "mfinitialve1ctor";

    private static final String DATA_STR = "data";
    private static final String ENCRYPT_DATA_STR = "encryptedData";

    /**
     * 可以作为类成员变量重复使用
     **/
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        // 检查是否是POST请求并且内容类型是JSON
        if ("POST".equalsIgnoreCase(request.getMethod()) && "application/json".equalsIgnoreCase(request.getContentType())) {
            // 包装HttpServletRequest以便可以多次读取InputStream
            HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapper(request) {
                private byte[] rawData;
                private boolean isDecrypted = false;

                @Override
                public ServletInputStream getInputStream() throws IOException {
                    if (rawData == null) {
                        rawData = IOUtils.toByteArray(super.getInputStream());
                        if (!isDecrypted) {
                            // 解密操作
                            try {
                                String requestBodyStr = new String(rawData, StandardCharsets.UTF_8);
                                JsonNode rootNode = objectMapper.readTree(requestBodyStr);
                                JsonNode encryptedNode = rootNode.get(ENCRYPT_DATA_STR);
                                if (encryptedNode != null) {
                                    String encryptedData = encryptedNode.asText();
                                    String decryptedValue = decrypt(encryptedData);
                                    rawData = decryptedValue.getBytes(StandardCharsets.UTF_8);
                                    isDecrypted = true;
                                }
                            } catch (Exception e) {
                                // 解密失败，可以根据实际情况进行处理
                                logger.error("doFilterInternal decrypt error: ", e);
                                throw new IOException("Error decrypting the request body", e);
                            }
                        }
                    }
                    return new ServletInputStreamWrapper(rawData);
                }

                @Override
                public BufferedReader getReader() throws IOException {
                    return new BufferedReader(new InputStreamReader(this.getInputStream(), StandardCharsets.UTF_8));
                }
            };
            filterChain.doFilter(wrappedRequest, response);
        } else {
            // 对于非POST或非JSON请求，不做处理直接传递给下一个过滤器
            filterChain.doFilter(request, response);
        }
    }

    private String decrypt(String encrypt_data) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
        SecretKeySpec key = new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), "AES");
        IvParameterSpec iv = new IvParameterSpec(INIT_VECTOR.getBytes(StandardCharsets.UTF_8));
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        byte[] original = cipher.doFinal(Base64.getDecoder().decode(encrypt_data));
        return new String(original);
    }


    private class ServletInputStreamWrapper extends ServletInputStream {
        private final ByteArrayInputStream bais;

        public ServletInputStreamWrapper(byte[] rawData) {
            this.bais = new ByteArrayInputStream(rawData);
        }

        @Override
        public int read() throws IOException {
            return bais.read();
        }

        @Override
        public boolean isFinished() {
            return bais.available() == 0;
        }

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setReadListener(ReadListener readListener) {
            throw new RuntimeException("Not implemented");
        }
    }
}