【小家Spring】从OncePerRequestFilter的源码解读去了解Spring内置的Filter的特别之处以及常见过滤器使用介绍

 *
 * <p>As of Servlet 3.0, a filter may be invoked as part of a
 * {@link javax.servlet.DispatcherType#REQUEST REQUEST} or
 * {@link javax.servlet.DispatcherType#ASYNC ASYNC} dispatches that occur in
 * separate threads. A filter can be configured in {@code web.xml} whether it
 * should be involved in async dispatches. However, in some cases servlet
 * containers assume different default configuration. 

@Override
public final void init(FilterConfig filterConfig) throws ServletException {}

@Component("helloFilter")
public class HelloFilter extends OncePerRequestFilter {

    @Override
    protected void initFilterBean() throws ServletException {
        System.out.println("Filter初始化...");
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        FilterConfig filterConfig = super.getFilterConfig();
        ServletContext servletContext = super.getServletContext();
        Environment environment = super.getEnvironment();

        filterChain.doFilter(request, response);
    }
}

	@Override
	public void afterPropertiesSet() throws ServletException {
		initFilterBean();
	}

	@Override
	public final void init(FilterConfig filterConfig) throws ServletException {
	...
	// Let subclasses do whatever initialization they like.
	initFilterBean();
	...
	}

super.getServletContext();

/**
* 过滤器基类，旨在确保每个请求调度在任何servlet容器上执行一次执行。 
* 它提供了一个带有HttpServletRequest和HttpServletResponse参数的{@link #doFilterInternal}方法。
*/
public abstract class OncePerRequestFilter extends GenericFilterBean { ... }

// 已过滤过的过滤器的固定后缀名
public static final String ALREADY_FILTERED_SUFFIX = ".FILTERED";

// 相当于生成已过滤的过滤器的名字（全局唯一的）
protected String getAlreadyFilteredAttributeName() {
	String name = getFilterName();
	if (name == null) {
		name = getClass().getName();
	}
	return name + ALREADY_FILTERED_SUFFIX;
}

//判断该请求是否是异步请求（Servlet 3.0后有异步请求,Spring MVC3.2开始）
protected boolean isAsyncDispatch(HttpServletRequest request) {
	return WebAsyncUtils.getAsyncManager(request).hasConcurrentResult();
}

//是否需要不过滤异步的请求（默认是不多次过滤异步请求的）
//javadoc：javax.servlet.DispatcherType.ASYNC的请求方式意味着可能在一个请求里这个过滤器会被多个不同线程调用多次，而这里返回true，就能保证只会被调用一次
protected boolean shouldNotFilterAsyncDispatch() {
	return true;
}

//原理基本同上
protected boolean shouldNotFilterErrorDispatch() {
	return true;
}

//可以人工直接返回true  那这个请求就肯定不会被过滤了~~~~
protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
	return false;
}

//这里很清楚的记录着  需要被跳过的请求们，这种请求直接就放行了
private boolean skipDispatch(HttpServletRequest request) {
	if (isAsyncDispatch(request) && shouldNotFilterAsyncDispatch()) {
		return true;
	}
	if (request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE) != null && shouldNotFilterErrorDispatch()) {
		return true;
	}
	return false;
}

	@Override
	public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		
		//只处理http请求
		if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
			throw new ServletException("OncePerRequestFilter just supports HTTP requests");
		}
		HttpServletRequest httpRequest = (HttpServletRequest) request;
		HttpServletResponse httpResponse = (HttpServletResponse) response;

		//判断这个请求是否需要执行过滤
		String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
		boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;

		if (hasAlreadyFilteredAttribute || skipDispatch(httpRequest) || shouldNotFilter(httpRequest)) {

			// 直接放行，不执行此过滤器的过滤操作
			filterChain.doFilter(request, response);
		} else {
			// 执行过滤，并且向请求域设置一个值，key就是生成的全局唯一的·alreadyFilteredAttributeName·
			request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
			try {
				//由子类自己去实现拦截的逻辑  注意 自己写时，filterChain.doFilter(request, response);这句代码不要忘了
				doFilterInternal(httpRequest, httpResponse, filterChain);
			}
			finally {
				// Remove the "already filtered" request attribute for this request.
				request.removeAttribute(alreadyFilteredAttributeName);
			}
		}
	}

// 如果在Spring应用程序上下文中初始化为bean，那么它将返回到bean工厂中定义的bean名称。
// 需要注意的是，如果是以bean的形式加入了。（比如Boot环境下），此时FilterConfig还未null的，所以有这个判断
@Nullable
protected String getFilterName() {
	return (this.filterConfig != null ? this.filterConfig.getFilterName() : this.beanName);
}

	<!-- characterEncodingFilter字符编码过滤器 -->
	<filter>
		<filter-name>characterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<!--要使用的字符集，一般我们使用UTF-8(保险起见UTF-8最好)-->
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<!--是否强制设置request的编码为encoding，默认false，不建议更改-->
			<param-name>forceRequestEncoding</param-name>
			<param-value>false</param-value>
		</init-param>
		<init-param>
			<!--是否强制设置response的编码为encoding，建议设置为true，下面有关于这个参数的解释-->
			<param-name>forceResponseEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>characterEncodingFilter</filter-name>
		<!--这里不能留空或者直接写 ' / ' ，否者不起作用-->
		<url-pattern>/*</url-pattern>
	</filter-mapping>

<Connector port="8080" protocol="HTTP/1.1" 
           connectionTimeout="20000"
           redirectPort="8443"
           parseBodyMethods="POST,PUT,DELETE"
           URIEncoding="UTF-8" />

    <filter>
        <filter-name>httpPutFormContentFilter</filter-name>
        <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>httpPutFormContentFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

private static class FormContentRequestWrapper extends HttpServletRequestWrapper { ... }

	@Override
	protected boolean shouldLog(HttpServletRequest request) {
		return logger.isDebugEnabled();
	}
	@Override
	protected void beforeRequest(HttpServletRequest request, String message) {
		logger.debug(message);
	}
	@Override
	protected void afterRequest(HttpServletRequest request, String message) {
		logger.debug(message);
	}

	@Override
	protected void beforeRequest(HttpServletRequest request, String message) {
		getServletContext().log(message);
	}

	@Override
	protected void afterRequest(HttpServletRequest request, String message) {
		getServletContext().log(message);
	}

public static final String DEFAULT_BEFORE_MESSAGE_PREFIX = "Before request [";
public static final String DEFAULT_BEFORE_MESSAGE_SUFFIX = "]";
public static final String DEFAULT_AFTER_MESSAGE_PREFIX = "After request [";
public static final String DEFAULT_AFTER_MESSAGE_SUFFIX = "]";
// 默认body体里只会打印出50个字符，自己可以自定义修改
private static final int DEFAULT_MAX_PAYLOAD_LENGTH = 50;

//true表示包含查询参数  形如：[  uri=xxx?a=xx&b=xxx  ]
private boolean includeQueryString = false;
//true表示包含客户端相关信息
private boolean includeClientInfo = false;
//true表示包含请求头信息
private boolean includeHeaders = false;
//true表示包含body体性息
private boolean includePayload = false;

	public void setMaxPayloadLength(int maxPayloadLength) {
		Assert.isTrue(maxPayloadLength >= 0, "'maxPayloadLength' should be larger than or equal to 0");
		this.maxPayloadLength = maxPayloadLength;
	}

	//自定义请求前、后的前缀、后缀等等  这个其实是建议定制的  个性化点比较好
	public void setBeforeMessagePrefix(String beforeMessagePrefix) {
		this.beforeMessagePrefix = beforeMessagePrefix;
	}
	
	//是否过滤异步的请求  这里false表示要过滤
	@Override
	protected boolean shouldNotFilterAsyncDispatch() {
		return false;
	}
	
	//生成日志消息的方法  这个强烈不建议调用者自己去做（当然，你要个性化，你随意）  getMessagePayload
	protected String createMessage(HttpServletRequest request, String prefix, String suffix) { ... }
	
	//这个非常的重要，判断哪些请求输出日志，哪些不需要输出。比如get请求，我们一般都不需要输出日志的 (至于能够实现标注指定注解接口采取输出日志呢？这个就做不到了，因为还没有到方法呢，没有办法拿到方法元信息)  但是若通过HandlerInterceptor来拦截，是可以处理方法注解的
	protected boolean shouldLog(HttpServletRequest request) {
		return true;
	}
	
	//在系统默认的message的基础上，你自己再去个性化吧。或者不用此message变量都成~  比如自己可以计算出请求耗时~
	protected abstract void beforeRequest(HttpServletRequest request, String message);
	protected abstract void afterRequest(HttpServletRequest request, String message);

    @ResponseBody
    @PostMapping(value = "/hello")
    public String helloPost(@RequestBody Map<String, Object> object) {
        //System.out.println(object);
        return "hello...Post";
    }

/**
 * 打印请求日志，默认打印get放，只打印POST、PUT、DELETE方法的请求日志哦~
 * 会计算出请求耗时、client请求的ip地址等等  contentType也会记录打印出来 信息比较全 方便查找问题~
 *
 * @author fangshixiang
 * @description
 * @date 2019-02-16 22:04
 */
@Slf4j
@WebFilter(urlPatterns = "/*")
public class RequestLogFilter extends AbstractRequestLoggingFilter {

    //这些配置都可以在init-param中进行设置,但是基于注解的，这里就不要这么麻烦了，统一在初始化的时候设置值吧
    //private boolean includeQueryString = false;
    //private boolean includeClientInfo = false;
    //private boolean includeHeaders = false;
    //private boolean includePayload = false;
    private static final String PROCESS_START_TIME_SUFFIX = ".PROCESS_START_TIME";

    @Override
    protected void initFilterBean() throws ServletException {
        super.setIncludeQueryString(true);
        super.setIncludeClientInfo(true);
        //因为headers里面的信息太多了 所以这里不输出了，否则过于干扰，只手动把content-type等关键信息输出即可
        super.setIncludeHeaders(false);
        super.setIncludePayload(true);
        super.setMaxPayloadLength(1000); //最大支持到1000个字符

        //头信息
        super.setBeforeMessagePrefix("请求开始 [");
        super.setBeforeMessageSuffix("]");
        super.setAfterMessagePrefix("请求结束 [");
        super.setAfterMessageSuffix("]");

    }

    @Override
    protected boolean shouldLog(HttpServletRequest request) {
        String method = request.getMethod();
        return HttpMethod.POST.matches(method) || HttpMethod.PUT.matches(method) || HttpMethod.DELETE.matches(method);
    }

    @Override
    protected void beforeRequest(HttpServletRequest request, String message) {
        logger.info(calcRequestTime(request)
                .concat(getConfigTypeLog(request))
                .concat(getThreadId())
                .concat(message));
    }

    @Override
    protected void afterRequest(HttpServletRequest request, String message) {
        logger.info(calcRequestTime(request)
                .concat(getConfigTypeLog(request))
                .concat(getThreadId())
                .concat(message));
    }

    //拼装contentType
    private String getConfigTypeLog(HttpServletRequest request) {
        String contentType = request.getContentType();
        String method = request.getMethod();
        return "[contentType=" + contentType + "] " + method.toUpperCase() + " ";
    }

    //计算请求耗时
    private String calcRequestTime(HttpServletRequest request) {
        long mills = 0;
        String requestTimeUniqueName = getRequestTimeUniqueName();

        Object processStartTime = request.getAttribute(requestTimeUniqueName);
        if (processStartTime == null) { //首次 放置值
            request.setAttribute(requestTimeUniqueName, Instant.now());
        } else { //请求结束的处理  开始计算吧
            Instant start = (Instant) processStartTime;
            Instant now = Instant.now();
            mills = Duration.between(start, now).toMillis();
			
            request.removeAttribute(requestTimeUniqueName);
        }
        return mills == 0 ? "" : ("[耗时:" + mills + "ms] ");

    }

    private String getRequestTimeUniqueName() {
        return this.getClass().getName().concat(PROCESS_START_TIME_SUFFIX);
    }

    private String getThreadId() {
        return "[ThreadId:" + Thread.currentThread().getId() + "] ";
    }

}