null
* {@link DefaultConnectionReuseStrategy#INSTANCE} will be used.
* @param responseFactory the response factory. If null
* {@link DefaultHttpResponseFactory#INSTANCE} will be used.
* @param handlerMapper the handler mapper. May be null.
* @param expectationVerifier the expectation verifier. May be null.
*
* @since 4.3
*/
public HttpService(
final HttpProcessor processor,
final ConnectionReuseStrategy connStrategy,
final HttpResponseFactory responseFactory,
final HttpRequestHandlerMapper handlerMapper,
final HttpExpectationVerifier expectationVerifier) {
super();
this.processor = Args.notNull(processor, "HTTP processor");
this.connStrategy = connStrategy != null ? connStrategy :
DefaultConnectionReuseStrategy.INSTANCE;
this.responseFactory = responseFactory != null ? responseFactory :
DefaultHttpResponseFactory.INSTANCE;
this.handlerMapper = handlerMapper;
this.expectationVerifier = expectationVerifier;
}
/**
* Create a new HTTP service.
*
* @param processor the processor to use on requests and responses
* @param connStrategy the connection reuse strategy. If null
* {@link DefaultConnectionReuseStrategy#INSTANCE} will be used.
* @param responseFactory the response factory. If null
* {@link DefaultHttpResponseFactory#INSTANCE} will be used.
* @param handlerMapper the handler mapper. May be null.
*
* @since 4.3
*/
public HttpService(
final HttpProcessor processor,
final ConnectionReuseStrategy connStrategy,
final HttpResponseFactory responseFactory,
final HttpRequestHandlerMapper handlerMapper) {
this(processor, connStrategy, responseFactory, handlerMapper, null);
}
/**
* Create a new HTTP service.
*
* @param processor the processor to use on requests and responses
* @param handlerMapper the handler mapper. May be null.
*
* @since 4.3
*/
public HttpService(
final HttpProcessor processor, final HttpRequestHandlerMapper handlerMapper) {
this(processor, null, null, handlerMapper, null);
}
/**
* @deprecated (4.1) set {@link HttpProcessor} using constructor
*/
@Deprecated
public void setHttpProcessor(final HttpProcessor processor) {
Args.notNull(processor, "HTTP processor");
this.processor = processor;
}
/**
* @deprecated (4.1) set {@link ConnectionReuseStrategy} using constructor
*/
@Deprecated
public void setConnReuseStrategy(final ConnectionReuseStrategy connStrategy) {
Args.notNull(connStrategy, "Connection reuse strategy");
this.connStrategy = connStrategy;
}
/**
* @deprecated (4.1) set {@link HttpResponseFactory} using constructor
*/
@Deprecated
public void setResponseFactory(final HttpResponseFactory responseFactory) {
Args.notNull(responseFactory, "Response factory");
this.responseFactory = responseFactory;
}
/**
* @deprecated (4.1) set {@link HttpResponseFactory} using constructor
*/
@Deprecated
public void setParams(final HttpParams params) {
this.params = params;
}
/**
* @deprecated (4.1) set {@link HttpRequestHandlerResolver} using constructor
*/
@Deprecated
public void setHandlerResolver(final HttpRequestHandlerResolver handlerResolver) {
this.handlerMapper = new HttpRequestHandlerResolverAdapter(handlerResolver);
}
/**
* @deprecated (4.1) set {@link HttpExpectationVerifier} using constructor
*/
@Deprecated
public void setExpectationVerifier(final HttpExpectationVerifier expectationVerifier) {
this.expectationVerifier = expectationVerifier;
}
/**
* @deprecated (4.3) no longer used.
*/
@Deprecated
public HttpParams getParams() {
return this.params;
}
/**
* Handles receives one HTTP request over the given connection within the
* given execution context and sends a response back to the client.
*
* @param conn the active connection to the client
* @param context the actual execution context.
* @throws IOException in case of an I/O error.
* @throws HttpException in case of HTTP protocol violation or a processing
* problem.
*/
public void handleRequest(
final HttpServerConnection conn,
final HttpContext context) throws IOException, HttpException {
context.setAttribute(HttpCoreContext.HTTP_CONNECTION, conn);
HttpResponse response = null;
try {
final HttpRequest request = conn.receiveRequestHeader();
if (request instanceof HttpEntityEnclosingRequest) {
if (((HttpEntityEnclosingRequest) request).expectContinue()) {
response = this.responseFactory.newHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_CONTINUE, context);
if (this.expectationVerifier != null) {
try {
this.expectationVerifier.verify(request, response, context);
} catch (final HttpException ex) {
response = this.responseFactory.newHttpResponse(HttpVersion.HTTP_1_0,
HttpStatus.SC_INTERNAL_SERVER_ERROR, context);
handleException(ex, response);
}
}
if (response.getStatusLine().getStatusCode() < 200) {
// Send 1xx response indicating the server expections
// have been met
conn.sendResponseHeader(response);
conn.flush();
response = null;
conn.receiveRequestEntity((HttpEntityEnclosingRequest) request);
}
} else {
conn.receiveRequestEntity((HttpEntityEnclosingRequest) request);
}
}
context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
if (response == null) {
response = this.responseFactory.newHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_OK, context);
this.processor.process(request, context);
doService(request, response, context);
}
// Make sure the request content is fully consumed
if (request instanceof HttpEntityEnclosingRequest) {
final HttpEntity entity = ((HttpEntityEnclosingRequest)request).getEntity();
EntityUtils.consume(entity);
}
} catch (final HttpException ex) {
response = this.responseFactory.newHttpResponse
(HttpVersion.HTTP_1_0, HttpStatus.SC_INTERNAL_SERVER_ERROR,
context);
handleException(ex, response);
}
context.setAttribute(HttpCoreContext.HTTP_RESPONSE, response);
this.processor.process(response, context);
conn.sendResponseHeader(response);
conn.sendResponseEntity(response);
conn.flush();
if (!this.connStrategy.keepAlive(response, context)) {
conn.close();
}
}
/**
* Handles the given exception and generates an HTTP response to be sent
* back to the client to inform about the exceptional condition encountered
* in the course of the request processing.
*
* @param ex the exception.
* @param response the HTTP response.
*/
protected void handleException(final HttpException ex, final HttpResponse response) {
if (ex instanceof MethodNotSupportedException) {
response.setStatusCode(HttpStatus.SC_NOT_IMPLEMENTED);
} else if (ex instanceof UnsupportedHttpVersionException) {
response.setStatusCode(HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED);
} else if (ex instanceof ProtocolException) {
response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
} else {
response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);
}
String message = ex.getMessage();
if (message == null) {
message = ex.toString();
}
final byte[] msg = EncodingUtils.getAsciiBytes(message);
final ByteArrayEntity entity = new ByteArrayEntity(msg);
entity.setContentType("text/plain; charset=US-ASCII");
response.setEntity(entity);
}
/**
* The default implementation of this method attempts to resolve an
* {@link HttpRequestHandler} for the request URI of the given request
* and, if found, executes its
* {@link HttpRequestHandler#handle(HttpRequest, HttpResponse, HttpContext)}
* method.
* * Super-classes can override this method in order to provide a custom * implementation of the request processing logic. * * @param request the HTTP request. * @param response the HTTP response. * @param context the execution context. * @throws IOException in case of an I/O error. * @throws HttpException in case of HTTP protocol violation or a processing * problem. */ protected void doService( final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException { HttpRequestHandler handler = null; if (this.handlerMapper != null) { handler = this.handlerMapper.lookup(request); } if (handler != null) { handler.handle(request, response, context); } else { response.setStatusCode(HttpStatus.SC_NOT_IMPLEMENTED); } } /** * Adaptor class to transition from HttpRequestHandlerResolver to HttpRequestHandlerMapper. */ @Deprecated private static class HttpRequestHandlerResolverAdapter implements HttpRequestHandlerMapper { private final HttpRequestHandlerResolver resolver; public HttpRequestHandlerResolverAdapter(final HttpRequestHandlerResolver resolver) { this.resolver = resolver; } public HttpRequestHandler lookup(final HttpRequest request) { return resolver.lookup(request.getRequestLine().getUri()); } } }