AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

HttpServletRequestWrapper、HttpServletResponseWrapper结合 过滤器 实现接口的加解密、国际化

2024-02-27 103
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： HttpServletRequestWrapper、HttpServletResponseWrapper结合 过滤器 实现接口的加解密、国际化


一、HttpServletRequestWrapper代码

package com.vteam.uap.security.httpWrapper;
import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
 * @author Miller.Lai
 * @description: 请求装饰器
 * @date 2023-12-18 11:09:46
 */
public class RequestWrapper extends HttpServletRequestWrapper {
    private byte[] bytes;
    private HttpServletRequest request;
    /**
     * @param request
     */
    public RequestWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;
    }
    public String getRequestBody() throws IOException {
        try (BufferedInputStream bis = new BufferedInputStream(request.getInputStream());
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) > 0) {
                baos.write(buffer, 0, len);
            }
            bytes = baos.toByteArray();
            String body = new String(bytes);
            return body;
        } catch (IOException ex) {
            throw ex;
        }
    }
    public void setRequestBody(String body){
        bytes = body.getBytes();
    }
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }
            @Override
            public boolean isReady() {
                return false;
            }
            @Override
            public void setReadListener(ReadListener readListener) {
            }
            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
    }
}

二、HttpServletRequestWrapper代码

package com.vteam.uap.security.httpWrapper;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.WriteListener;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpServletResponseWrapper;
import java.io.*;
/**
 * @author Miller.Lai
 * @description: 响应装饰器
 * @date 2023-12-15 13:29:16
 */
public class ResponseWrapper extends HttpServletResponseWrapper {
    private ByteArrayOutputStream outputStream;
    public byte[] getResponseData(){
        try {
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return outputStream.toByteArray();
    }
    public ResponseWrapper(HttpServletResponse response) {
        super(response);
        this.outputStream =new ByteArrayOutputStream();
    }
    @Override
    public PrintWriter getWriter() throws IOException {
        return new PrintWriter(outputStream);
    }
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return new ServletOutputStream() {
            @Override
            public boolean isReady() {
                return false;
            }
            @Override
            public void setWriteListener(WriteListener listener) {
            }
            @Override
            public void write(int b) throws IOException {
                outputStream.write(b);
            }
        };
    }
}

三、加解密过滤器代码

package com.vteam.uap.core.filter;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.vteam.uap.common.util.*;
import com.vteam.uap.security.codec.CodecProperties;
import com.vteam.uap.security.httpWrapper.RequestWrapper;
import com.vteam.uap.security.httpWrapper.ResponseWrapper;
import jakarta.annotation.Resource;
import jakarta.servlet.Filter;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.util.PatternMatchUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import java.io.IOException;
import java.util.Objects;
/**
 * @author Miller.Lai
 * @description:  加解码过滤器
 * @date 2023-12-15 16:46:03
 */
@Slf4j
public class CodecFilter implements Filter {
    @Resource
    protected CodecProperties codecProperties;
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 请求解密
        if (codecProperties.isApiEnable() && !isIgnore() && ("POST".equals(((HttpServletRequest)request).getMethod().trim().toUpperCase())) && "application/json".equals(request.getContentType().trim().toLowerCase())){
            RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest) request);
            String bodyStr =  requestWrapper.getRequestBody();
            if(StringUtils.isNotBlank(bodyStr)){
                JSONObject bodyJson = JSONObject.parseObject(bodyStr);
                Object data = bodyJson.get("data");
                if(data != null && data instanceof String && ((String)data).trim().length () !=0 ){
                    if (log.isDebugEnabled()) {
                        log.debug("解密 API 请求消息：type={}, requestBody={}",requestWrapper.getMethod(), bodyJson.toJSONString());
                    }
                    String plainText = AesUtils.decrypt((String) data, AesUtils.Mode.API,codecProperties.getAesKey(),codecProperties.getAesIv(),codecProperties.isDbEnable());
                    bodyJson.put("data",JSONObject.parseObject(plainText));
                    requestWrapper.setRequestBody(bodyJson.toJSONString());
                }
            }
           // 包装响应对象
            ResponseWrapper responseWrapper = new ResponseWrapper((HttpServletResponse) response);
            chain.doFilter(requestWrapper, responseWrapper);
            // 拿到响应对象
            byte[] responseData = responseWrapper.getResponseData();
            if("application/json".equals(responseWrapper.getContentType().trim().toLowerCase())){
                String originalResulet = new String(responseData);
                JSONObject jsonObject  =JSONObject.parseObject(originalResulet);
                // 拿到响应对象中的data
                Object data = jsonObject.get("data");
                if(data != null){
                    String encText = AesUtils.encrypt(JSON.toJSONString(data), AesUtils.Mode.API,codecProperties.getAesKey(),codecProperties.getAesIv(),codecProperties.isDbEnable());
                    jsonObject.put("data", encText);
                }
                responseData = jsonObject.toJSONString().getBytes("utf-8");
            }
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            response.setContentLength(responseData.length);
            httpServletResponse.getOutputStream().write(responseData);
            httpServletResponse.getOutputStream().flush();
        }else{
            // 处理业务逻辑
            chain.doFilter(request, response);
        }
    }
    @Override
    public void destroy() {
    }
    protected boolean isIgnore() {
        boolean isIgnore = false;
        String[] ignoreUrl = codecProperties.getIgnoreUrl();
        if (ArrayUtils.isNotEmpty(ignoreUrl)) {
            HttpServletRequest request =
                    ((ServletRequestAttributes) Objects.requireNonNull(
                            RequestContextHolder.getRequestAttributes())).getRequest();
            for (String s : ignoreUrl) {
                if (PatternMatchUtils.simpleMatch(s, request.getRequestURI())) {
                    isIgnore = true;
                    break;
                }
            }
        }
        return isIgnore;
    }
}

四、国际化过滤器代码

package com.vteam.uap.core.filter;
import com.alibaba.fastjson2.JSONObject;
import com.vteam.uap.common.constant.CommonConstants;
import com.vteam.uap.common.util.GlobalConstants;
import com.vteam.uap.common.util.I18NUtils;
import com.vteam.uap.common.util.StringUtils;
import com.vteam.uap.common.util.UuidUtil;
import com.vteam.uap.security.httpWrapper.ResponseWrapper;
import jakarta.servlet.*;
import jakarta.servlet.Filter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.PatternMatchUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import java.io.IOException;
import java.util.Objects;
/**
 * @author Miller.Lai
 * @description:
 * @date 2023-12-15 16:46:03
 */
@Slf4j
public class I18NFilter implements Filter {
    @Value("${uap.i18n.enable:false}")
    private boolean i18nEnable;
    @Value("${uap.i18n.language:zh_CN}")
    private String language;
    @Value("${uap.i18n.ignore-url:/doc.html,/webjars/**,/v3/api-docs/**,/actuator**,/favicon.ico}")
    private String ignoreUrl;
    @Value("${uap.response.msg.include-request-id:false}")
    private boolean msgIncludeRequestId;
    public I18NFilter() {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 如果开启了国际化则进行国际化处理
        if (i18nEnable && !isIgnore()) {
            // 包装响应对象
            ResponseWrapper customResponseWrapper = new ResponseWrapper((HttpServletResponse) response);
            // 处理业务逻辑
            chain.doFilter(request, customResponseWrapper);
            // 拿到响应对象
            byte[] responseData = customResponseWrapper.getResponseData();
            if("application/json".equals(customResponseWrapper.getContentType().trim().toLowerCase())){
                String originalResulet = new String(responseData);
                JSONObject jsonObject  =JSONObject.parseObject(originalResulet);
                // 拿到响应对象中的msg
                String msg = (String)jsonObject.get("msg");
                String i18nMsg = null;
                if ( StringUtils.isNotBlank(msg) ) {
                    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
                    String languageInheader = httpServletRequest.getHeader("Language");
                    // 优先使用请求头里的国际化语言
                    if (languageInheader != null) {
                        i18nMsg = I18NUtils.getI18N(msg, languageInheader);
                    } else {
                        i18nMsg = I18NUtils.getI18N(msg, language);
                    }
                }else if( StringUtils.isNotBlank(msg) ){// 不进行国际化也要清除相关缓存
                    I18NUtils.getActualContainBraceMsgParamMap().remove(msg+GlobalConstants.Symbol.UNDERLINE+Thread.currentThread().getId());
                    I18NUtils.getActualContainBraceMsgMap().remove(msg+GlobalConstants.Symbol.UNDERLINE+Thread.currentThread().getId());
                }
                if(i18nMsg != null ){
                    msg = i18nMsg;
                }
                if(msg == null){
                    msg = "";
                }
                // 如果线程号不存在，则进行设置
                if(StringUtils.isEmpty(MDC.get("UUID"))){
                    MDC.put("UUID", UuidUtil.getShortUuid());
                }
                // msg中携带请求id返回
                if(msgIncludeRequestId ){
                    msg = MDC.get("UUID") + GlobalConstants.Symbol.SPACE + msg ;
                }
                jsonObject.put("msg", msg);
                responseData =  jsonObject.toJSONString().getBytes("utf-8");
            }
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            response.setContentLength(responseData.length);
            httpServletResponse.getOutputStream().write(responseData);
            httpServletResponse.getOutputStream().flush();
        }else{
            // 处理业务逻辑
            chain.doFilter(request, response);
        }
    }
    @Override
    public void destroy() {
    }
    protected boolean isIgnore() {
        boolean isIgnore = false;
        if(StringUtils.isEmpty(ignoreUrl)){
            return false;
        }
        String[] ignoreUrls = ignoreUrl.split(CommonConstants.Symbol.COMMA);
        if (ArrayUtils.isNotEmpty(ignoreUrls)) {
            HttpServletRequest request =
                    ((ServletRequestAttributes) Objects.requireNonNull(
                            RequestContextHolder.getRequestAttributes())).getRequest();
            for (String s : ignoreUrls) {
                if (PatternMatchUtils.simpleMatch(s, request.getRequestURI())) {
                    isIgnore = true;
                    break;
                }
            }
        }
        return isIgnore;
    }
}

五、过滤器注册

/**
     * 国际化过滤器
     * @return
     */
    @Bean
    public I18NFilter i18NFilter() {
        return new I18NFilter();
    }
    @Bean
    public FilterRegistrationBean i18NFilterRegistrationBean() {
        // 新建过滤器注册类
        FilterRegistrationBean registration = new FilterRegistrationBean();
        // 添加自定义 过滤器
        registration.setFilter(i18NFilter());
        // 设置过滤器的URL模式
        registration.addUrlPatterns("/*");
        //设置过滤器顺序
        registration.setOrder(4);
        return registration;
    }
    /**
     * 请求加解密过滤器
     * @return
     */
    @Bean
    public CodecFilter codecFilter() {
        return new CodecFilter();
    }
    @Bean
    public FilterRegistrationBean codecFilterRegistrationBean() {
        // 新建过滤器注册类
        FilterRegistrationBean registration = new FilterRegistrationBean();
        // 添加自定义 过滤器
        registration.setFilter(codecFilter());
        // 设置过滤器的URL模式
        registration.addUrlPatterns("/*");
        //设置过滤器顺序
        registration.setOrder(3);
        return registration;
    }

     本人近十年JAVA架构设计经验，长期从事IT技术资源整合。有志于自我技术提升、需要最新IT技术课程的小伙伴，可私信联系我 ，粉丝一律友情价

文章标签：
Java
季风泯灭的季节
目录
相关文章
季风泯灭的季节
|
8月前
|
安全 数据安全/隐私保护
【接口加密】理解接口加密的基础概念
【接口加密】理解接口加密的基础概念
季风泯灭的季节
421 0
程序员朱永胜
|
前端开发 数据安全/隐私保护
传参统一jwt加密（坑）
传参统一jwt加密（坑）
程序员朱永胜
118 0
WangBai
|
30天前
|
Java Spring
过滤器实现方式
Spring Cloud Gateway 的过滤器用于处理HTTP请求和响应，支持日志记录、请求转发、权限校验等。内置过滤器如AddRequestHeader、RewritePath、SetStatus等，可自定义以满足特定需求。
WangBai
23 0
yuanzhengme
|
8月前
|
安全 架构师 Java
SpringBoot【集成 jasypt】实现配置信息自定义加解密（自定义的属性探测和密码解析器）
SpringBoot【集成 jasypt】实现配置信息自定义加解密（自定义的属性探测和密码解析器）
yuanzhengme
919 0
王同学睡醒了
|
数据采集 前端开发 算法
前端加密的常见场景和方法
前端加密的常见场景和方法
王同学睡醒了
471 0
a816120
|
前端开发 数据安全/隐私保护
若依框架添加出入参加密解密
若依框架添加出入参加密解密
a816120
1279 0
javpower
|
数据安全/隐私保护
自定义注解@Cryptography实现请求体、响应体的脱敏/加密/解密
基于自定义注解快速实现场景需求
javpower
135 0
自定义注解@Cryptography实现请求体、响应体的脱敏/加密/解密
前端歌谣
|
前端开发
前端学习笔记202303学习笔记第五天-私有过滤器和全局过滤器
前端学习笔记202303学习笔记第五天-私有过滤器和全局过滤器
前端歌谣
75 0
云内容小助手
|
JSON 安全 Java
分布式整合之重写认证的过滤器|学习笔记
快速学习分布式整合之重写认证的过滤器
云内容小助手
116 0
分布式整合之重写认证的过滤器|学习笔记
悟空码字
AOP + 注解 实现通用的接口参数校验
写移动端接口的时候，为了校验参数，传统的做法是加各种判断，写了很多重复的代码，而且也不美观。为了增加代码复用性，美观的校验参数，采用AOP + 注解的方式来实现接口的参数校验（使用拦截器也可以实现），在需要校验参数的方法上加上自定义的注解即可。
悟空码字
319 0
AOP + 注解 实现通用的接口参数校验