Java HttpResponse.setStatusCode方法代码示例

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    RequestLine line = request.getRequestLine();
    Uri uri = Uri.parse(line.getUri());
    DatabaseDataEntity entity;
    if (uri != null) {
        String database = uri.getQueryParameter("database");
        String tableName = uri.getQueryParameter("table");
        entity = getDataResponse(database, tableName);
        if (entity != null) {
            response.setStatusCode(200);
            response.setEntity(new StringEntity(ParserJson.getSafeJsonStr(entity), "utf-8"));
            return;
        }
    }
    entity = new DatabaseDataEntity();
    entity.setDataList(new ArrayList<Map<String, String>>());
    entity.setCode(BaseEntity.FAILURE_CODE);
    response.setStatusCode(200);
    response.setEntity(new StringEntity(ParserJson.getSafeJsonStr(entity), "utf-8"));
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    Log.d("plan", "DatabaseTableRequestHandler");
    DatabaseEntity entity;
    String uri = request.getRequestLine().getUri();
    String key =  Uri.parse(uri).getQueryParameter("database_name");
    if (!TextUtils.isEmpty(key)) {
        entity = getTableResponse(key.trim());
    }  else {
        entity = new DatabaseEntity();
        entity.setCode(BaseEntity.FAILURE_CODE);
        entity.setDataList(new ArrayList<SimpleNameEntity>());
    }
    String result = ParserJson.getSafeJsonStr(entity);
    response.setStatusCode(200);
    response.setEntity(new StringEntity(result, "utf-8"));
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
/**
 * 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();
    }
    byte[] msg = EncodingUtils.getAsciiBytes(message);
    ByteArrayEntity entity = new ByteArrayEntity(msg);
    entity.setContentType("text/plain; charset=US-ASCII");
    response.setEntity(entity);
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    //处于线程之中.
    Log.d("plan", "DatabaseQueryRequestHanlder");
    response.setEntity(new StringEntity(getDataResponse(), "utf-8"));
    response.setStatusCode(200);
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    Log.d("plan", "DataAndTableRequestHandler");
    DataAndTableEntity entity = getDatabaseAndTable();
    if (entity == null) {
        entity = new DataAndTableEntity();
        entity.setCode(BaseEntity.FAILURE_CODE);
        entity.setDataList(new ArrayList<Map<String, List<SimpleNameEntity>>>());
    }
    response.setStatusCode(200);
    response.setEntity(new StringEntity(ParserJson.getSafeJsonStr(entity), "utf-8"));
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public final void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    if (!this.allowedVerbs.contains(request.getRequestLine().getMethod().toUpperCase())) {
        response.setStatusCode(http403.responseCode);
        response.setEntity(http403.entity);
    } else {
        Tuple<String, Map<String, String>> pathAndQueryTuple = PathHelper.splitPathAndQuery(request.getRequestLine().getUri().substring(this.prefix.length()));
        String path = pathAndQueryTuple.o1;

        Map<String, String> query = pathAndQueryTuple.o2;

        if (this.isAuthorized(path, query)) {
            try {
                Response res = getResponse(path, query);
                response.setStatusCode(res.responseCode);
                response.setHeaders(res.headers);
                response.setEntity(res.entity);
            } catch (Exception ex) {
                response.setStatusCode(http500.responseCode);
                response.setEntity(http500.entity);
                ex.printStackTrace();
            }
        } else {
            response.setStatusCode(http403.responseCode);
            response.setEntity(http403.entity);
        }
    }
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
private DefaultBotSession getDefaultBotSession() throws IOException {
    HttpResponse response = new BasicHttpResponse(new BasicStatusLine(
            new ProtocolVersion("HTTP", 1, 1), 200, ""));
    response.setStatusCode(200);
    response.setEntity(new StringEntity("{}"));

    HttpClient mockHttpClient = Mockito.mock(HttpClient.class);
    Mockito.when(mockHttpClient.execute(Mockito.any(HttpPost.class)))
            .thenReturn(response);
    DefaultBotSession session = new DefaultBotSession();
    session.setCallback(new FakeLongPollingBot());
    session.setOptions(new DefaultBotOptions());
    return session;
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context)
        throws HttpException, IOException {

    response.setStatusCode(HttpStatus.SC_MOVED_PERMANENTLY);
    response.addHeader("Location", PropagationHandler.MAPPING);
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
@Test
public void test() throws ExecutionException, InterruptedException {


    HttpHost target = new HttpHost("localhost");
    BasicConnPool connpool = new BasicConnPool();
    connpool.setMaxTotal(200);
    connpool.setDefaultMaxPerRoute(10);
    connpool.setMaxPerRoute(target, 20);
    Future<BasicPoolEntry> future = connpool.lease(target, null);
    BasicPoolEntry poolEntry = future.get();
    HttpClientConnection conn = poolEntry.getConnection();

    HttpProcessor httpproc = HttpProcessorBuilder.create()
            .add(new ResponseDate())
            .add(new ResponseServer("MyServer-HTTP/1.1"))
            .add(new ResponseContent())
            .add(new ResponseConnControl())
            .build();

    HttpRequestHandler myRequestHandler = new HttpRequestHandler() {

        public void handle(
                HttpRequest request,
                HttpResponse response,
                HttpContext context) throws HttpException, IOException {
            response.setStatusCode(HttpStatus.SC_OK);
            response.setEntity(
                    new StringEntity("some important message",
                            ContentType.TEXT_PLAIN));
        }

    };

    UriHttpRequestHandlerMapper handlerMapper = new UriHttpRequestHandlerMapper();
    handlerMapper.register("/service/*", myRequestHandler);
    HttpService httpService = new HttpService(httpproc, handlerMapper);
}
 

import org.apache.http.HttpResponse; //导入方法依赖的package包/类
/**
 * 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.
 * <p>
 * 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.handlerResolver != null) {
        String requestURI = request.getRequestLine().getUri();
        handler = this.handlerResolver.lookup(requestURI);
    }
    if (handler != null) {
        handler.handle(request, response, context);
    } else {
        response.setStatusCode(HttpStatus.SC_NOT_IMPLEMENTED);
    }
}