Servlet 3.0异步特性初探

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

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

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

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