Java Response.setSuspended方法代码示例

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Invoke the next Valve in the sequence. When the invoke returns, check
 * the response state, and output an error report is necessary.
 *
 * @param request The servlet request to be processed
 * @param response The servlet response to be created
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet error occurs
 */
public void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Perform the request
    getNext().invoke(request, response);

    Throwable throwable =
        (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR);

    if (response.isCommitted()) {
        return;
    }

    if (throwable != null) {

        // The response is an error
        response.setError();

        // Reset the response (if possible)
        try {
            response.reset();
        } catch (IllegalStateException e) {
            ;
        }

        response.sendError
            (HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

    }

    response.setSuspended(false);

    try {
        report(request, response, throwable);
    } catch (Throwable tt) {
        ;
    }

}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Invoke the next Valve in the sequence. When the invoke returns, check
 * the response state. If the status code is greater than or equal to 400
 * or an uncaught exception was thrown then the error handling will be
 * triggered.
 *
 * @param request The servlet request to be processed
 * @param response The servlet response to be created
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet error occurs
 */
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {

    // Perform the request
    getNext().invoke(request, response);

    if (response.isCommitted()) {
        if (response.setErrorReported()) {
            // Error wasn't previously reported but we can't write an error
            // page because the response has already been committed. Attempt
            // to flush any data that is still to be written to the client.
            try {
                response.flushBuffer();
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
            }
            // Close immediately to signal to the client that something went
            // wrong
            response.getCoyoteResponse().action(ActionCode.CLOSE_NOW, null);
        }
        return;
    }

    Throwable throwable = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

    // If an async request is in progress and is not going to end once this
    // container thread finishes, do not process any error page here.
    if (request.isAsync() && !request.isAsyncCompleting()) {
        return;
    }

    if (throwable != null && !response.isError()) {
        // Make sure that the necessary methods have been called on the
        // response. (It is possible a component may just have set the
        // Throwable. Tomcat won't do that but other components might.)
        // These are safe to call at this point as we know that the response
        // has not been committed.
        response.reset();
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    }

    // One way or another, response.sendError() will have been called before
    // execution reaches this point and suspended the response. Need to
    // reverse that so this valve can write to the response.
    response.setSuspended(false);

    try {
        report(request, response, throwable);
    } catch (Throwable tt) {
        ExceptionUtils.handleThrowable(tt);
    }
}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Select the appropriate child Context to process this request,
 * based on the specified request URI.  If no matching Context can
 * be found, return an appropriate HTTP error.
 *
 * @param request Request to be processed
 * @param response Response to be produced
 * @param valveContext Valve context used to forward to the next Valve
 *
 * @exception IOException if an input/output error occurred
 * @exception ServletException if a servlet error occurred
 */
public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Select the Context to be used for this Request
    Context context = request.getContext();
    if (context == null) {
        response.sendError
            (HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
             sm.getString("standardHost.noContext"));
        return;
    }

    // Bind the context CL to the current thread
    if( context.getLoader() != null ) {
        // Not started - it should check for availability first
        // This should eventually move to Engine, it's generic.
        Thread.currentThread().setContextClassLoader
                (context.getLoader().getClassLoader());
    }

    // Ask this Context to process this request
    context.getPipeline().getFirst().invoke(request, response);

    // Access a session (if present) to update last accessed time, based on a
    // strict interpretation of the specification
    if (Globals.STRICT_SERVLET_COMPLIANCE) {
        request.getSession(false);
    }

    // Error page processing
    response.setSuspended(false);

    Throwable t = (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR);

    if (t != null) {
        throwable(request, response, t);
    } else {
        status(request, response);
    }

    // Restore the context classloader
    Thread.currentThread().setContextClassLoader
        (StandardHostValve.class.getClassLoader());

}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Handle an HTTP status code or Java exception by forwarding control
 * to the location included in the specified errorPage object.  It is
 * assumed that the caller has already recorded any request attributes
 * that are to be forwarded to this page.  Return <code>true</code> if
 * we successfully utilized the specified error page location, or
 * <code>false</code> if the default error report should be rendered.
 *
 * @param request The request being processed
 * @param response The response being generated
 * @param errorPage The errorPage directive we are obeying
 */
protected boolean custom(Request request, Response response,
                         ErrorPage errorPage) {

    if (container.getLogger().isDebugEnabled())
        container.getLogger().debug("Processing " + errorPage);

    request.setPathInfo(errorPage.getLocation());

    try {

        // Reset the response (keeping the real error code and message)
        response.resetBuffer(true);

        // Forward control to the specified location
        ServletContext servletContext =
            request.getContext().getServletContext();
        RequestDispatcher rd =
            servletContext.getRequestDispatcher(errorPage.getLocation());
        rd.forward(request.getRequest(), response.getResponse());

        // If we forward, the response is suspended again
        response.setSuspended(false);

        // Indicate that we have successfully processed this custom page
        return (true);

    } catch (Throwable t) {

        // Report our failure to process this custom page
        container.getLogger().error("Exception Processing " + errorPage, t);
        return (false);

    }

}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Invoke the next Valve in the sequence. When the invoke returns, check the
 * response state. If the status code is greater than or equal to 400 or an
 * uncaught exception was thrown then the error handling will be triggered.
 *
 * @param request
 *            The servlet request to be processed
 * @param response
 *            The servlet response to be created
 *
 * @exception IOException
 *                if an input/output error occurs
 * @exception ServletException
 *                if a servlet error occurs
 */
@Override
public void invoke(Request request, Response response) throws IOException, ServletException {

	// Perform the request
	getNext().invoke(request, response);

	if (response.isCommitted()) {
		if (response.setErrorReported()) {
			// Error wasn't previously reported but we can't write an error
			// page because the response has already been committed. Attempt
			// to flush any data that is still to be written to the client.
			try {
				response.flushBuffer();
			} catch (Throwable t) {
				ExceptionUtils.handleThrowable(t);
			}
			// Close immediately to signal to the client that something went
			// wrong
			response.getCoyoteResponse().action(ActionCode.CLOSE_NOW, null);
		}
		return;
	}

	Throwable throwable = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

	// If an async request is in progress and is not going to end once this
	// container thread finishes, do not process any error page here.
	if (request.isAsync() && !request.isAsyncCompleting()) {
		return;
	}

	if (throwable != null && !response.isError()) {
		// Make sure that the necessary methods have been called on the
		// response. (It is possible a component may just have set the
		// Throwable. Tomcat won't do that but other components might.)
		// These are safe to call at this point as we know that the response
		// has not been committed.
		response.reset();
		response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
	}

	// One way or another, response.sendError() will have been called before
	// execution reaches this point and suspended the response. Need to
	// reverse that so this valve can write to the response.
	response.setSuspended(false);

	try {
		report(request, response, throwable);
	} catch (Throwable tt) {
		ExceptionUtils.handleThrowable(tt);
	}
}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Handle an HTTP status code or Java exception by forwarding control
 * to the location included in the specified errorPage object.  It is
 * assumed that the caller has already recorded any request attributes
 * that are to be forwarded to this page.  Return <code>true</code> if
 * we successfully utilized the specified error page location, or
 * <code>false</code> if the default error report should be rendered.
 *
 * @param request The request being processed
 * @param response The response being generated
 * @param errorPage The errorPage directive we are obeying
 */
private boolean custom(Request request, Response response,
                         ErrorPage errorPage) {

    if (container.getLogger().isDebugEnabled())
        container.getLogger().debug("Processing " + errorPage);

    try {
        // Forward control to the specified location
        ServletContext servletContext =
            request.getContext().getServletContext();
        RequestDispatcher rd =
            servletContext.getRequestDispatcher(errorPage.getLocation());

        if (rd == null) {
            container.getLogger().error(
                sm.getString("standardHostValue.customStatusFailed", errorPage.getLocation()));
            return false;
        }

        if (response.isCommitted()) {
            // Response is committed - including the error page is the
            // best we can do 
            rd.include(request.getRequest(), response.getResponse());
        } else {
            // Reset the response (keeping the real error code and message)
            response.resetBuffer(true);
            response.setContentLength(-1);

            rd.forward(request.getRequest(), response.getResponse());

            // If we forward, the response is suspended again
            response.setSuspended(false);
        }

        // Indicate that we have successfully processed this custom page
        return (true);

    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // Report our failure to process this custom page
        container.getLogger().error("Exception Processing " + errorPage, t);
        return (false);

    }
}
 

import org.apache.catalina.connector.Response; //导入方法依赖的package包/类
/**
 * Handle an HTTP status code or Java exception by forwarding control to the
 * location included in the specified errorPage object. It is assumed that
 * the caller has already recorded any request attributes that are to be
 * forwarded to this page. Return <code>true</code> if we successfully
 * utilized the specified error page location, or <code>false</code> if the
 * default error report should be rendered.
 *
 * @param request
 *            The request being processed
 * @param response
 *            The response being generated
 * @param errorPage
 *            The errorPage directive we are obeying
 */
private boolean custom(Request request, Response response, ErrorPage errorPage) {

	if (container.getLogger().isDebugEnabled())
		container.getLogger().debug("Processing " + errorPage);

	try {
		// Forward control to the specified location
		ServletContext servletContext = request.getContext().getServletContext();
		RequestDispatcher rd = servletContext.getRequestDispatcher(errorPage.getLocation());

		if (rd == null) {
			container.getLogger()
					.error(sm.getString("standardHostValue.customStatusFailed", errorPage.getLocation()));
			return false;
		}

		if (response.isCommitted()) {
			// Response is committed - including the error page is the
			// best we can do
			rd.include(request.getRequest(), response.getResponse());
		} else {
			// Reset the response (keeping the real error code and message)
			response.resetBuffer(true);
			response.setContentLength(-1);

			rd.forward(request.getRequest(), response.getResponse());

			// If we forward, the response is suspended again
			response.setSuspended(false);
		}

		// Indicate that we have successfully processed this custom page
		return (true);

	} catch (Throwable t) {
		ExceptionUtils.handleThrowable(t);
		// Report our failure to process this custom page
		container.getLogger().error("Exception Processing " + errorPage, t);
		return (false);

	}
}