springboot 中拦截器与过滤器的区别是什么，两种方式的使用场景分别是什么？
拦截器（Interceptor）和过滤器（Filter）是Spring Boot中常用的两种请求处理机制，它们有以下区别和使用场景：
区别：
- 拦截器是基于Java反射机制实现的，而过滤器是基于Servlet规范实现的。
- 拦截器只能对Spring MVC的请求进行拦截处理，而过滤器可以对所有的请求进行拦截处理，包括静态资源请求。
- 拦截器可以访问Spring MVC的上下文（如HandlerMethod等），而过滤器无法直接访问。
使用场景：
- 拦截器适用于对特定的Controller请求进行预处理、后处理、日志记录等操作，如权限验证、日志记录等。
- 过滤器适用于对所有的请求进行统一的处理，如字符编码转换、请求参数过滤、请求响应压缩等。
总结：
- 如果需要对特定的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");
}
}
}
