Java AsyncContext.setTimeout方法代码示例

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
public void service(HttpServletRequest request, HttpServletResponse response) {
  if (transport == null) {
    transport = CseContext.getInstance().getTransportManager().findTransport(Const.RESTFUL);
  }

  // 异步场景
  final AsyncContext asyncCtx = request.startAsync();
  asyncCtx.addListener(restAsyncListener);
  asyncCtx.setTimeout(ServletConfig.getServerTimeout());

  HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request);
  HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response);

  RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation();
  restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters);
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
    TestAsyncContextImpl.track("DispatchingServletGet-");
    resp.flushBuffer();

    final boolean first = TrackingServlet.first;
    TrackingServlet.first = false;

    final AsyncContext ctxt = req.startAsync();
    TrackingListener listener = new TrackingListener(false, true, null);
    ctxt.addListener(listener);
    ctxt.setTimeout(3000);

    Runnable run = new Runnable() {
        @Override
        public void run() {
            if (first) {
                ctxt.dispatch("/stage1");
            } else {
                ctxt.dispatch("/stage2");
            }
        }
    };
    if ("y".equals(req.getParameter("useThread"))) {
        new Thread(run).start();
    } else {
        run.run();
    }
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void doDispatch(final HttpServletRequest request, final HttpServletResponse response) throws Exception {

    final AsyncContext ac = request.startAsync(request, response);

    ac.setTimeout(TIME_OUT);

    // FIXME: convert to Lambda
    FutureTask task = new FutureTask(new Runnable() {

        @Override
        public void run() {
            try {
                logger.debug("Dispatching request " + request);
                AsyncDispatcherServlet.super.doDispatch(request, response);
                logger.debug("doDispatch returned from processing request " + request);
                ac.complete();
            } catch (Exception ex) {
                logger.error("Error in async request", ex);
            }
        }
    }, null);

    ac.addListener(new AsyncDispatcherServletListener(task));
    exececutor.execute(task);
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
    if (req.isAsyncSupported()) {
        TestAsyncContextImpl.track("TimeoutServletGet-");
        final AsyncContext ac = req.startAsync();
        ac.setTimeout(ASYNC_TIMEOUT);

        if (completeOnTimeout != null) {
            ac.addListener(new TrackingListener(false,
                    completeOnTimeout.booleanValue(), dispatchUrl));
        }
    } else {
        resp.getWriter().print("FAIL: Async unsupported");
    }
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
/**
 * Method for stream initialization
 * @param clientUri - Client Uri
 * @param request - The servlet request object
 * @param response - The servlet Response Object
 */
private void init(String clientUri,HttpServletRequest request, HttpServletResponse response){
	LOG.info("Response Stream Inititated");
	try{
		HttpSession session = request.getSession();
		session.setMaxInactiveInterval(72*60*60);
		EventClient client = new EventClient();
		client.connectToClient(clientUri);
		response.setHeader("Content-Type", "text/event-stream");
		response.setHeader("Cache-Control", "no-cache, no-store");
		response.setHeader("Connection", "keep-alive");
		AsyncContext asyncContext = request.startAsync(request,response);
		asyncContext.setTimeout(72*60*60*1000);
		asyncContext.getResponse().setBufferSize(1200);
		try {
			asyncContext.getResponse().flushBuffer();
		} catch (IOException e1) {
			ErrorLog.logError(e1.getMessage(),e1.getStackTrace());
		}
		ServletContext servletContext = request.getServletContext();
		Map<String,AsyncContext> responseStreams = (ConcurrentHashMap<String,AsyncContext>) servletContext.getAttribute("responseStreams");
		responseStreams.put(clientUri,asyncContext);
	} catch (Exception e){
		ErrorLog.logError(e.getMessage(),e.getStackTrace());
	}
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
/**
 * buildProcCallback
 * 
 * @param callBack
 * @param request
 * @return
 */
private AsyncReqProcWithHttpClientCallback buildProcCallback(HttpClientCallback callBack,
        HttpServletRequest request) {

    AsyncContext ac = request.startAsync();

    AsyncReqProcWithHttpClientCallback proc = new AsyncReqProcWithHttpClientCallback(ac, callBack);

    ac.addListener(proc);
    ac.setTimeout(2500);
    return proc;
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    if (bug55772IsSecondRequest) {
        Cookie[] cookies = req.getCookies();
        if (cookies != null && cookies.length > 0) {
            for (Cookie cookie : req.getCookies()) {
                if (cookie.getName().equalsIgnoreCase("something.that.should.not.leak")) {
                    bug55772RequestStateLeaked = true;
                }
            }
        }
        bug55772Latch3.countDown();
    } else {
        req.getCookies(); // We have to do this so Tomcat will actually parse the cookies from the request
    }

    req.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", Boolean.TRUE);
    AsyncContext asyncContext = req.startAsync();
    asyncContext.setTimeout(5000);

    bug55772Latch1.countDown();

    PrintWriter writer = asyncContext.getResponse().getWriter();
    writer.print('\n');
    writer.flush();

    bug55772Latch2.countDown();
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

    resp.setContentType("text/plain");
    resp.setCharacterEncoding("UTF-8");

    final OutputStream os = resp.getOutputStream();

    final AsyncContext asyncCtxt = req.startAsync();
    asyncCtxt.setTimeout(3000);

    t = new Thread(new Runnable() {

        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                try {
                    // Some tests depend on this write failing (e.g.
                    // because the client has gone away). In some cases
                    // there may be a large (ish) buffer to fill before
                    // the write fails.
                    for (int j = 0 ; j < 8; j++) {
                        os.write(BYTES_8K);
                    }
                    os.flush();
                    Thread.sleep(1000);
                } catch (Exception e) {
                    log.info("Exception caught " + e);
                    try {
                        // Note if request times out before this
                        // exception is thrown and the complete call
                        // below is made, the complete call below will
                        // fail since the timeout will have completed
                        // the request.
                        asyncCtxt.complete();
                        break;
                    } finally {
                        completed = true;
                    }
                }
            }
        }
    });
    t.setName("testBug54928");
    t.start();
}
 

import javax.servlet.AsyncContext; //导入方法依赖的package包/类
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    final AsyncContext actx = req.startAsync();
    actx.setTimeout(30*1000);
    actx.dispatch("/jsp/async/async3.jsp");
}