SpringBoot 过滤器Filter的使用

Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

可通过过滤器，对请求进行拦截，比如读取session判断用户是否登录、判断访问的请求URL是否有访问权限(黑白名单)等。主要还是可对请求进行预处理。
过滤器和拦截器触发时机不一样，过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。

打印日志

不要过滤资源文件下的静态页面，否则一直重定向到登录会出现死循环，界面无法正常跳转。

@Component
@WebFilter(filterName = "urlFilter", urlPatterns = "/*")
public class UrlFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {   }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException
    {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        String requestURI = request.getRequestURI();
        if(requestURI.equals("")|| requestURI.equals("/")|| !requestURI.contains("/wxtRent"))
        {
            response.sendRedirect("/wxtRent/login.html");
            return;
        }
        if ("GET".equals(request.getMethod())) {
            if (request.getQueryString() != null) {
                url.append("?").append(request.getQueryString());
            }
        }
        if (request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            Map<String, String[]> formData = request.getParameterMap();
            ArrayList<Map<String, String>> headerList = new ArrayList<>();
            HashMap<String, String> headerMaps = new HashMap<>();
            for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements(); ) {
                String name = e.nextElement();
                headerMaps.put(name, request.getHeader(name));
            }
            headerList.add(headerMaps);
            log.info("--> " + request.getMethod() + " " + url.toString() + "\n" + JSON.toJSONString(formData) + "\n" + headerList);
        }
        //打印JSON数据
        if (request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)) {
            MyRequestWrapper myRequestWrapper = null;
            try {
                myRequestWrapper = new MyRequestWrapper(request);
            } catch (Exception e) {
                log.error(e.getMessage());
            }
            filterChain.doFilter(myRequestWrapper, response);
            return;
        }
        filterChain.doFilter(request, response);
    }

    @Override
    public void destroy(){ }
}

MyRequestWrapper

public class MyRequestWrapper extends HttpServletRequestWrapper {

	private byte[] body;

	public MyRequestWrapper(HttpServletRequest httpServletRequest) {
		super(httpServletRequest);
		String requestData = getBodyString(httpServletRequest);
		this.body = requestData.getBytes(StandardCharsets.UTF_8);
		log.info("--> " + httpServletRequest.getMethod() + " " + httpServletRequest.getRequestURL() + "\n" + requestData);
	}

	/**
	 * 获取请求Body
	 *
	 * @param request
	 * @return
	 */
	public String getBodyString(final ServletRequest request){
		StringBuilder sb = new StringBuilder();
		InputStream inputStream = null;
		BufferedReader reader = null;
		try {
			inputStream = cloneInputStream(request.getInputStream());
			reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
			String line = "";
			while ((line = reader.readLine()) != null){
				sb.append(line);
			}
		}catch (Exception e){
			log.error(e.getMessage());
		}finally {
			if(inputStream != null){
				try {
					inputStream.close();
				}catch (Exception ignored){}
			}
			if(reader != null){
				try {
					reader.close();
				}catch (Exception ignored){}
			}
		}
		return sb.toString();
	}

	/**
	 * Description: 复制输入流
	 *
	 * @param inputStream
	 * @return
	 */
	public InputStream cloneInputStream(ServletInputStream inputStream){
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		byte[] b = new byte[1024];
		int len;
		try {
			while ((len = inputStream.read(b)) > -1){
				byteArrayOutputStream.write(b, 0, len);
			}
			byteArrayOutputStream.flush();
		}catch (Exception e){
			log.error(e.getMessage());
		}
		return new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
	}

	@Override
	public BufferedReader getReader() throws IOException{
		return new BufferedReader(new InputStreamReader(getInputStream()));
	}
	@Override
	public ServletInputStream getInputStream() throws IOException{
		final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);

		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(); }
		};
	}
}

跨域处理

https://blog.csdn.net/qq_19636353/article/details/126302533

参考资料

Spring Boot实战：拦截器与过滤器
https://www.cnblogs.com/paddix/p/8365558.html

springboot 日志打印完整json格式的请求参数
https://blog.csdn.net/mefly521/article/details/106922091/