编程

当前位置:时时彩平台 > 编程 > JAVA入门[15]-过滤器filter

JAVA入门[15]-过滤器filter

来源:http://www.mrmtshipyard.com 作者:时时彩平台 时间:2019-09-27 14:40

Servlet 是 Java 为了编写服务端程序而定义的一个接口规范,在 Servlet 3.0 以后支持了异步的操作。

一、过滤器

过滤器是可用于 Servlet 编程的 Java 类,可以实现以下目的:

  • 在客户端的请求访问后端资源之前,拦截这些请求。
  • 在服务器的响应发送回客户端之前,处理这些响应。

参考:

最近项目添加了一个代码热部署的功能,在客户端输入信号,信号到达 Web 服务器后,需要 Web 服务器将信号以 UDP 的方式递送给另外一个网关服务器,网关服务器再以同样的通信方式返回信号,最后在返回给客户端。如图。

二、如何实现和配置过滤器

图片 1

1.定义过滤器

过滤器实现接口: javax.servlet.Filter

示例:定义过滤器实现计数器,counterFilter实现Filter接口

public class counterFilter implements Filter {
    ServletContext context;
    int count;
    public void init(FilterConfig filterConfig) throws ServletException {
        context=filterConfig.getServletContext();
        String initCount=filterConfig.getInitParameter("count");
        count= Integer.valueOf(initCount);
    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        context.log("===counterFilter do Filter====");
        count++;
        context.setAttribute("count",count);
        filterChain.doFilter(servletRequest,servletResponse);
    }

    public void destroy() {
    }
}

  

jsp调用:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<div>欢迎,您是第 <%=application.getAttribute("count")%> 位访客</div>

  

说到异步,自然会联想到它的对立『同步』。操作系统的知识告诉我们,异步/同步实际上是指的一种消息通信机制。

2.配置web.xml

过滤器是可插拔的,通过web.xml来声明,然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。

当 Web 容器启动 Web 应用程序时,它会为部署描述符中声明的每一个过滤器创建一个实例。

web.xml 中的 filter-mapping 元素的顺序决定了 Web 容器应用过滤器到 Servlet 的顺序。若要反转过滤器的顺序,只需要在 web.xml 文件中反转 filter-mapping 元素即可。

<filter>
    <filter-name>counterFilter</filter-name>
    <filter-class>filter.counterFilter</filter-class>
    <init-param>
        <param-name>count</param-name>
        <param-value>100</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>counterFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

  

由于在项目中 Web 服务器接受 UDP 信号是使用的异步线程,所以必须要使用到 Servlet 的异步特性,这是一个原因。

3.如何给过滤器设置参数?

在web.xml中用init-param节点设置参数,然后在 init 方法使用 FilterConfig 对象获取参数。

context=filterConfig.getServletContext();
String initCount=filterConfig.getInitParameter("count");

  

传统的 Servlet 规范中,一个 Web 服务器(即 Servlet 容器)同时会接收到多个 HTTP 请求,其中一个请求对应一个线程处理,这个处理线程会涉及到业务逻辑处理,甚至是数据库查询,这些都是很费时的。

三、使用注解@WebFilter定义过滤器

@WebFilter注解可以实现了javax.servlet.Filter接口的类定义为过滤器组件

 

@WebFilter(filterName = "filter1",initParams =@WebInitParam(name = "count",value = "100"),urlPatterns = "/*")
public class filter1 implements Filter {
    ServletContext context;
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        context.log("filter1.doFilter()");
        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {
        context=config.getServletContext();
    }
}

  

执行顺序:默认按照filter的名字排序,如果想调整顺序,还是要配置filter-mapping节点。

<filter-mapping>
        <filter-name>filter2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter-mapping>
        <filter-name>filter1</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

 

查看一下Tomcat Localhost Log:

02-Jun-2017 13:26:20.182 信息 [RMI TCP Connection(3)-127.0.0.1] org.apache.catalina.core.ApplicationContext.log Initializing Spring root WebApplicationContext
02-Jun-2017 13:26:21.302 信息 [RMI TCP Connection(3)-127.0.0.1] org.apache.catalina.core.ApplicationContext.log Initializing Spring FrameworkServlet 'springmvc'
02-Jun-2017 13:26:24.716 信息 [http-nio-8092-exec-1] org.apache.catalina.core.ApplicationContext.log ===counterFilter do Filter====
02-Jun-2017 13:26:24.716 信息 [http-nio-8092-exec-1] org.apache.catalina.core.ApplicationContext.log filter2.doFilter()
02-Jun-2017 13:26:24.716 信息 [http-nio-8092-exec-1] org.apache.catalina.core.ApplicationContext.log filter1.doFilter()

  

如果使用传统的 Servlet 同步规范,举个极端的例子:一个 Tomcat 服务器最多同时支持 150 个并发请求,假设一个请求加上逻辑处理和数据库操作一次耗时 5s ,如果在 5s 内同时有 150 个人发来了 HTTP 请求,这时 Tomcat 的处理能力正好满足需求,如果这时候需要做代码的热部署,再向 Web 服发送 HTTP 请求的话,那么就会造成等待。

四、一个应用场景:过滤器防止中文编码

public class EncodeFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request=(HttpServletRequest)servletRequest;
        HttpServletResponse response=(HttpServletResponse)servletResponse;
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        filterChain.doFilter(request,response);;
    }

    public void destroy() {

    }
}

综合上面两个因素,不得不使用到 Servlet 的异步特性。

首先就是异步 Servlet 中最重要的一个接口 AsyncContext,它的源代码如下:

public interface AsyncContext {     //  获得一次请求中的 request 对象
     public ServletRequest getRequest(); 
     //  获得一次请求中的 response 对象     public ServletResponse getResponse();     //  检查 AsyncContext 是否由原生的 request 和 response 对象初始化生成
     public boolean hasOriginalRequestAndResponse();     //  
     public void dispatch();     //
     public void dispatch(String path);     //
     public void dispatch(ServletContext context, String path);     //  将由 request 开启的异步操作设置为完成状态, 并关闭 response
     public void complete();     //  调用此方法, Servlet 容器会分发一个线程来执行传进来的 Runnable 任务, 并且会向 Runnable 任务中传入必要的上下文信息, 即开启一个异步周期
     public void start(Runnable run);     //  把指定的异步监听 AsyncListner 注册到 AsyncContext 中, 在一个异步周期中任何的 complete, time out, error 事件都会被监听器监听
     public void addListener(AsyncListener listener);   
     public void addListener(AsyncListener listener, ServletRequest servletRequest, ServletResponse servletResponse);
     public <T extends AsyncListener> T createListener(Class<T> clazz) throws ServletException;     //  为开启的异步周期设置超时时间, 如果不手动设置, 容器会为我们设置一个默认的超时时间
     public void setTimeout(long timeout);     //
     public long getTimeout();}

在上面提到了异步监听器 AsyncListner,下面来看看这个监听器的接口规范是什么样的:

public interface AsyncListener extends EventListener {     public void onComplete(AsyncEvent event) throws IOException;     public void onTimeout(AsyncEvent event) throws IOException;     public void onError(AsyncEvent event) throws IOException;     public void onStartAsync(AsyncEvent event) throws IOException;}    

传入一个 AsyncEvent 异步事件,来完成各种监听。观察 AsyncEvent 源代码知道这个异步事件的构成:

public class AsyncEvent {     private AsyncContext context;    private ServletRequest request;    private ServletResponse response;    private Throwable throwable;
    public AsyncEvent(AsyncContext context, ServletRequest request, ServletResponse response, Throwable throwable) {        this.context = context;        this.request = request;        this.response = response;        this.throwable = throwable;    }}

之所以在异步事件里保管 request 和 response 的引用,是因为需要通过触发的异步事件对客户端进行响应,要进行响应自然要用到 response 对象。

下面通过一个例子来看一看 异步 Servlet 规范到底如何使用:

public class LoadClassServlet extends HttpServlet {    private static final long serialVersionUID = 1L;    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        doPost(req, resp);    }    @Override    protected void doPost(HttpServletRequest request, HttpServletResponse response)            throws ServletException, IOException {        System.out.println(" Start Servlet " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;        System.out.println(" doPost() Thread Name : " + Thread.currentThread().getName;                System.out.println( " In doPost " + request);        System.out.println( " In doPost " + response);        request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);        //  开启异步周期        AsyncContext asyncContext = request.startAsync();        asyncContext.setTimeout(10*1000);        asyncContext.start(new Runnable() {                        @Override            public void run() {                try {                    System.out.println(" run() Thread Name : " + Thread.currentThread().getName;                    //  模拟启用线程异步递送信号, 一般来说是一些耗时的操作                    System.out.println(" Before Sleep " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;                    Thread.sleep(5 * 1000);                    System.out.println(" After Sleep " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;                    asyncContext.complete();                    System.out.println(" After complete() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });        System.out.println( " In AsyncContext " + asyncContext.getRequest;        System.out.println( " In AsyncContext " + asyncContext.getResponse;                asyncContext.addListener( new AsyncListener() {            @Override            public void onTimeout(AsyncEvent event) throws IOException {                //  /////////////////////////////////////                //  这个方法内一般会写一些关于超时的逻辑                //  假设10s还没有收到返回的信号, 就将错误消息                //  在这里通过response对象返回给客户端                //  /////////////////////////////////////                System.out.println(" onTimeout() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;                                event.getSuppliedResponse().getWriter().println(" timeout ");            }                        @Override            public void onStartAsync(AsyncEvent event) throws IOException {                System.out.println(" onStartAsync() ");            }                        @Override            public void onError(AsyncEvent event) throws IOException {                System.out.println(" onError() ");            }                        @Override            public void onComplete(AsyncEvent event) throws IOException {                //  ///////////////////////////                //  这个方法无论怎样都会被调用                //  不管是手动调用complete()方法                //  还是超时, 这个方法都会被执行                //  ///////////////////////////                                System.out.println(" onComplete() " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;                System.out.println(" onComplete() Thread Name : " + Thread.currentThread().getName;                System.out.println( " In AsyncEvent "+event.getSuppliedRequest;                System.out.println( " In AsyncEvent "+event.getSuppliedResponse;                                event.getSuppliedResponse().getWriter().println(" complete ");            }        } );        System.out.println( " End of Servlet " + DateUtil.getDefaultFormatDate(System.currentTimeMillis;    }}

首先只打开关于 request 和 response 对象的打印语句,在浏览器请求此 Servlet,截取相关的输出如下:

In doPost org.apache.catalina.connector.RequestFacade@4500c794
In doPost org.apache.catalina.connector.ResponseFacade@307fd18d

In AsyncContext org.apache.catalina.connector.RequestFacade@4500c794
In AsyncContext org.apache.catalina.connector.ResponseFacade@307fd18d

In AsyncEvent org.apache.catalina.connector.RequestFacade@4500c794
In AsyncEvent org.apache.catalina.connector.ResponseFacade@307fd18d

可以看到 3 个地方的打印出来的 request 和 response 对象都是同一个。

为了方便控制台浏览,现在将所有 request 和 response 的打印都注释掉。

为了弄清楚异步 Servlet 的执行流程,观察四种情况下的控制台打印情况。

< 1 > 休眠时间为 5s,休眠结束后立即调用 complete() 方法

请求 Servlet,控制台打印如下:

Start Servlet 2018-10-27 18:57:20
doPost() Thread Name : http-nio-8080-exec-7
run() Thread Name : http-nio-8080-exec-1
Before Sleep 2018-10-27 18:57:20
End of Servlet 2018-10-27 18:57:20
After Sleep 2018-10-27 18:57:25
After complete() 2018-10-27 18:57:25
onComplete() 2018-10-27 18:57:25
onComplete() Thread Name : http-nio-8080-exec-8

浏览器输出为:

图片 2

异步操作执行 5s 后,手动调用 complete() 方法,onCmplete() 监听方法被执行,并向浏览器输出 complete 字符串,这是一种情况。

< 2 >休眠时间改为 15s,休眠结束后立即调用 complete() 方法

请求 Servlet,控制台打印如下:

Start Servlet 2018-10-27 18:59:09
doPost() Thread Name : http-nio-8080-exec-2
run() Thread Name : http-nio-8080-exec-4
Before Sleep 2018-10-27 18:59:09
End of Servlet 2018-10-27 18:59:09
onTimeout() 2018-10-27 18:59:20
onComplete() 2018-10-27 18:59:20
onComplete() Thread Name : http-nio-8080-exec-5
After Sleep 2018-10-27 18:59:24

浏览器输出为:

图片 3

< 3 > 休眠时间为 5s,休眠结束后不调用complete()方法

请求 Servlet,控制台打印如下:

Start Servlet 2018-10-27 19:10:42
doPost() Thread Name : http-nio-8080-exec-2
run() Thread Name : http-nio-8080-exec-3
Before Sleep 2018-10-27 19:10:42
End of Servlet 2018-10-27 19:10:42
After Sleep 2018-10-27 19:10:47
onTimeout() 2018-10-27 19:10:53
onComplete() 2018-10-27 19:10:53
onComplete() Thread Name : http-nio-8080-exec-4

浏览器输出为:

图片 4

< 4 > 休眠时间为 15s,休眠结束后不调用complete()方法

请求 Servlet,控制台打印如下:

Start Servlet 2018-10-27 19:13:11
doPost() Thread Name : http-nio-8080-exec-3
run() Thread Name : http-nio-8080-exec-7
Before Sleep 2018-10-27 19:13:11
End of Servlet 2018-10-27 19:13:11
onTimeout() 2018-10-27 19:13:22
onComplete() 2018-10-27 19:13:22
onComplete() Thread Name : http-nio-8080-exec-5
After Sleep 2018-10-27 19:13:26

浏览器输出为:

图片 5

分析四种打印结果,得出以下几个结论:

  1. 监听器的 onComplete 方法无论怎样都会执行,要么是调用 AsyncContext#complete 方法后执行,要么是超时时间到了自动执行。
  2. 只有在设定的 Timeout 时间内调用AsyncContext#complete 方法才不会触发 onTimeout 方法,其余情况都会被触发执行。
  3. 另外有趣的一点是,执行过程中出现了 3 个不同的线程,分别是:处理 HTTP 请求的线程;异步执行模拟递送信号的线程(异步线程也可以使用自己创建的线程);执行回调监听方法的线程

在实际应用中,一般不会像上面例子那样使用 Web 容器为我们分配的线程。从上面的打印就能看出,在 Tomcat 的实现中,调用 AsyncContex#start() 后,默认使用的的异步线程是处理 HTTP 请求的线程,这样虽然能达到异步的目的,但是对于提高请求的并发量没起到作用。

所以一般的做法是,自己维护一个异步处理的线程池,维护的线程数量一般大于 Web 容器用来处理 HTTP 请求的线程数。这样既能实现异步操作,又能提高 HTTP 请求处理的并发量。

本文由时时彩平台发布于编程,转载请注明出处:JAVA入门[15]-过滤器filter

关键词:

上一篇:没有了

下一篇:没有了