关于SpringBoot使用过滤器替换指定字符

关于SpringBoot使用过滤器替换指定字符

什么是过滤器（Filter）

过滤器，顾名思义就是起到过滤筛选作用的一种事物，只不过相较于现实生活中的过滤器，这里的过滤器过滤的对象是客户端访问的web资源，也可以理解为一种预处理手段，对资源进行拦截后，将其中我们认为的杂质（用户自己定义的）过滤，符合条件的放行，不符合的则拦截下来，如下图：

实现过滤器替换指定字符

1、创建config组件

注：如果是过滤指定地址的话需要将 registrationBean.addUrlPatterns("/*");改为

registrationBean.setUrlPatterns(new ArrayList());

2、创建Filter

package com.eliansun.Filter;

import com.eliansun.framework.ParameterRequestWrapper;
import org.springframework.stereotype.Component;

import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @description: 过滤指定字符
 * @author wangjia
 * @date: 2020/10/28 10:43 上午
 * @return
 */
 @Component
 @WebFilter(urlPatterns = "/**",filterName = "ParamsFilter",dispatcherTypes = DispatcherType.REQUEST)
public class ParamsFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ParameterRequestWrapper parmsRequest = new ParameterRequestWrapper((HttpServletRequest) servletRequest);
        filterChain.doFilter(parmsRequest, servletResponse);

    }
}

3、创建字符转换实现类

package com.eliansun.framework;

import com.alibaba.fastjson.JSON;
import com.eliansun.Constant.FilterConstans;
import com.eliansun.util.StringJsonUtil;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author wangjia
 * @description: 字符转换
 * @date: 2020/10/28 10:52 上午
 * @return
 */
public class ParameterRequestWrapper extends HttpServletRequestWrapper {

    private Map<String, String[]> params = new HashMap<>();

    public ParameterRequestWrapper(HttpServletRequest request) {
        // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
        super(request);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        Map<String, String[]> requestMap = request.getParameterMap();
        this.params.putAll(requestMap);
        this.modifyParameterValues();
    }

    /**
     * 重写getInputStream方法  post类型的请求参数必须通过流才能获取到值
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        //非json类型，直接返回
       /* if(!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)){
            return super.getInputStream();
        }*/
        if (!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_UTF8_VALUE)) {
            return super.getInputStream();
        }
        //为空，直接返回
        String json = IOUtils.toString(super.getInputStream(), "utf-8");
        if (StringUtils.isEmpty(json)) {
            return super.getInputStream();
        }
        Map<String, Object> map = StringJsonUtil.jsonStringToMap(json);
        ByteArrayInputStream bis = new ByteArrayInputStream(JSON.toJSONString(map).getBytes("utf-8"));
        return new MyServletInputStream(bis);
    }

    /**
     * 将parameter的值去除空格后重写回去
     */
    public void modifyParameterValues() {
        Set<String> set = params.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            String[] values = replaceMap(params.get(key));
            params.put(key, values);
        }
    }

    /**
     * @return
     * @description: 替换静态常量的map的值
     * @author wangjia
     * @date: 2020/10/28 3:03 下午
     */
    public String[] replaceMap(String[] values) {
        Map<String, String> map = FilterConstans.map;
        for (Map.Entry<String, String> vo : map.entrySet()) {
            values[0] = values[0].replace(vo.getKey(), vo.getValue());
        }
        values[0].replaceAll(" ", "");
        return values;
    }

    /**
     * 重写getParameter 参数从当前类中的map获取
     */
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    /**
     * 重写getParameterValues
     */
    @Override
    public String[] getParameterValues(String name) {//同上
        return params.get(name);
    }

    class MyServletInputStream extends ServletInputStream {
        private ByteArrayInputStream bis;

        public MyServletInputStream(ByteArrayInputStream bis) {
            this.bis = bis;
        }

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

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

        @Override
        public void setReadListener(ReadListener listener) {

        }

        @Override
        public int read() {
            return bis.read();
        }
    }

}

4、自定义map替换符

package com.eliansun.Constant;

import java.util.HashMap;
import java.util.Map;

public class FilterConstans {
    public static Map<String,String> map = new HashMap<>();
    static {
        map.put(">","&gt;");
        map.put("<","&lt;");
    }
}