Java HttpRequest类代码示例

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
/** Flushes entries that were invalidated by the given response
 * received for the given host/request pair.
 */
public void flushInvalidatedCacheEntries(final HttpHost host,
        final HttpRequest request, final HttpResponse response) {
    final int status = response.getStatusLine().getStatusCode();
    if (status < 200 || status > 299) {
        return;
    }
    final URL reqURL = getAbsoluteURL(cacheKeyGenerator.getURI(host, request));
    if (reqURL == null) {
        return;
    }
    final URL contentLocation = getContentLocationURL(reqURL, response);
    if (contentLocation != null) {
        flushLocationCacheEntry(reqURL, response, contentLocation);
    }
    final URL location = getLocationURL(reqURL, response);
    if (location != null) {
        flushLocationCacheEntry(reqURL, response, location);
    }
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public void process(final HttpRequest request, final HttpContext context)
    throws HttpException, IOException {
    Args.notNull(request, "HTTP request");
    if (!request.containsHeader(HTTP.USER_AGENT)) {
        String s = null;
        final HttpParams params = request.getParams();
        if (params != null) {
            s = (String) params.getParameter(CoreProtocolPNames.USER_AGENT);
        }
        if (s == null) {
            s = this.userAgent;
        }
        if (s != null) {
            request.addHeader(HTTP.USER_AGENT, s);
        }
    }
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
/**
 * Waits for and receives a response.
 * This method will automatically ignore intermediate responses
 * with status code 1xx.
 *
 * @param request   the request for which to obtain the response
 * @param conn      the connection over which the request was sent
 * @param context   the context for receiving the response
 *
 * @return  the terminal response, not yet post-processed
 *
 * @throws IOException in case of an I/O error.
 * @throws HttpException in case of HTTP protocol violation or a processing
 *   problem.
 */
protected HttpResponse doReceiveResponse(
        final HttpRequest request,
        final HttpClientConnection conn,
        final HttpContext context) throws HttpException, IOException {
    Args.notNull(request, "HTTP request");
    Args.notNull(conn, "Client connection");
    Args.notNull(context, "HTTP context");
    HttpResponse response = null;
    int statusCode = 0;

    while (response == null || statusCode < HttpStatus.SC_OK) {

        response = conn.receiveResponseHeader();
        if (canResponseHaveBody(request, response)) {
            conn.receiveResponseEntity(response);
        }
        statusCode = response.getStatusLine().getStatusCode();

    } // while intermediate response

    return response;
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public void process(final HttpRequest request, final HttpContext context)
        throws HttpException, IOException {
    Args.notNull(request, "HTTP request");
    Args.notNull(context, "HTTP context");

    final String method = request.getRequestLine().getMethod();
    if (method.equalsIgnoreCase("CONNECT")) {
        return;
    }

    if (request.containsHeader(AUTH.WWW_AUTH_RESP)) {
        return;
    }

    // Obtain authentication state
    final AuthState authState = (AuthState) context.getAttribute(
            ClientContext.TARGET_AUTH_STATE);
    if (authState == null) {
        this.log.debug("Target auth state not set in the context");
        return;
    }
    if (this.log.isDebugEnabled()) {
        this.log.debug("Target auth state: " + authState.getState());
    }
    process(authState, request, context);
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public void process(final HttpRequest request, final HttpContext context)
        throws HttpException, IOException {
    Args.notNull(request, "HTTP request");

    if (!request.containsHeader(HTTP.EXPECT_DIRECTIVE)) {
        if (request instanceof HttpEntityEnclosingRequest) {
            final ProtocolVersion ver = request.getRequestLine().getProtocolVersion();
            final HttpEntity entity = ((HttpEntityEnclosingRequest)request).getEntity();
            // Do not send the expect header if request body is known to be empty
            if (entity != null
                    && entity.getContentLength() != 0 && !ver.lessEquals(HttpVersion.HTTP_1_0)) {
                final HttpClientContext clientContext = HttpClientContext.adapt(context);
                final RequestConfig config = clientContext.getRequestConfig();
                if (config.isExpectContinueEnabled()) {
                    request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE);
                }
            }
        }
    }
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public DefaultManagedHttpClientConnection(
        final String id,
        final int buffersize,
        final int fragmentSizeHint,
        final CharsetDecoder chardecoder,
        final CharsetEncoder charencoder,
        final MessageConstraints constraints,
        final ContentLengthStrategy incomingContentStrategy,
        final ContentLengthStrategy outgoingContentStrategy,
        final HttpMessageWriterFactory<HttpRequest> requestWriterFactory,
        final HttpMessageParserFactory<HttpResponse> responseParserFactory) {
    super(buffersize, fragmentSizeHint, chardecoder, charencoder,
            constraints, incomingContentStrategy, outgoingContentStrategy,
            requestWriterFactory, responseParserFactory);
    this.id = id;
    this.attributes = new ConcurrentHashMap<String, Object>();
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
private RequestProtocolError requestHasWeakETagAndRange(final HttpRequest request) {
    // TODO: Should these be looking at all the headers marked as Range?
    final String method = request.getRequestLine().getMethod();
    if (!(HeaderConstants.GET_METHOD.equals(method))) {
        return null;
    }

    final Header range = request.getFirstHeader(HeaderConstants.RANGE);
    if (range == null) {
        return null;
    }

    final Header ifRange = request.getFirstHeader(HeaderConstants.IF_RANGE);
    if (ifRange == null) {
        return null;
    }

    final String val = ifRange.getValue();
    if (val.startsWith("W/")) {
        return RequestProtocolError.WEAK_ETAG_AND_RANGE_ERROR;
    }

    return null;
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
/**
 * Produces a digest authorization string for the given set of
 * {@link Credentials}, method name and URI.
 *
 * @param credentials A set of credentials to be used for athentication
 * @param request    The request being authenticated
 *
 * @throws ch.boye.httpclientandroidlib.auth.InvalidCredentialsException if authentication credentials
 *         are not valid or not applicable for this authentication scheme
 * @throws AuthenticationException if authorization string cannot
 *   be generated due to an authentication failure
 *
 * @return a digest authorization string
 */
@Override
public Header authenticate(
        final Credentials credentials,
        final HttpRequest request,
        final HttpContext context) throws AuthenticationException {

    Args.notNull(credentials, "Credentials");
    Args.notNull(request, "HTTP request");
    if (getParameter("realm") == null) {
        throw new AuthenticationException("missing realm in challenge");
    }
    if (getParameter("nonce") == null) {
        throw new AuthenticationException("missing nonce in challenge");
    }
    // Add method name and request-URI to the parameter map
    getParameters().put("methodname", request.getRequestLine().getMethod());
    getParameters().put("uri", request.getRequestLine().getUri());
    final String charset = getParameter("charset");
    if (charset == null) {
        getParameters().put("charset", getCredentialsCharset(request));
    }
    return createDigestHeader(credentials, request);
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
void storeVariantEntry(
        final HttpHost target,
        final HttpRequest req,
        final HttpCacheEntry entry) throws IOException {
    final String parentURI = uriExtractor.getURI(target, req);
    final String variantURI = uriExtractor.getVariantURI(target, req, entry);
    storage.putEntry(variantURI, entry);

    final HttpCacheUpdateCallback callback = new HttpCacheUpdateCallback() {

        public HttpCacheEntry update(final HttpCacheEntry existing) throws IOException {
            return doGetUpdatedParentEntry(
                    req.getRequestLine().getUri(), existing, entry,
                    uriExtractor.getVariantKey(req, entry),
                    variantURI);
        }

    };

    try {
        storage.updateEntry(parentURI, callback);
    } catch (final HttpCacheUpdateException e) {
        log.warn("Could not update key [" + parentURI + "]", e);
    }
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
/**
 * Check entry against If-None-Match
 * @param request The current httpRequest being made
 * @param entry the cache entry
 * @return boolean does the etag validator match
 */
private boolean etagValidatorMatches(final HttpRequest request, final HttpCacheEntry entry) {
    final Header etagHeader = entry.getFirstHeader(HeaderConstants.ETAG);
    final String etag = (etagHeader != null) ? etagHeader.getValue() : null;
    final Header[] ifNoneMatch = request.getHeaders(HeaderConstants.IF_NONE_MATCH);
    if (ifNoneMatch != null) {
        for (final Header h : ifNoneMatch) {
            for (final HeaderElement elt : h.getElements()) {
                final String reqEtag = elt.toString();
                if (("*".equals(reqEtag) && etag != null)
                        || reqEtag.equals(etag)) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
/**
 * Test to see if the {@link HttpRequest} is HTTP1.1 compliant or not
 * and if not, we can not continue.
 *
 * @param request the HttpRequest Object
 * @return list of {@link RequestProtocolError}
 */
public List<RequestProtocolError> requestIsFatallyNonCompliant(final HttpRequest request) {
    final List<RequestProtocolError> theErrors = new ArrayList<RequestProtocolError>();

    RequestProtocolError anError = requestHasWeakETagAndRange(request);
    if (anError != null) {
        theErrors.add(anError);
    }

    if (!weakETagOnPutDeleteAllowed) {
        anError = requestHasWeekETagForPUTOrDELETEIfMatch(request);
        if (anError != null) {
            theErrors.add(anError);
        }
    }

    anError = requestContainsNoCacheDirectiveWithFieldName(request);
    if (anError != null) {
        theErrors.add(anError);
    }

    return theErrors;
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public LoggingManagedHttpClientConnection(
        final String id,
        final HttpClientAndroidLog log,
        final HttpClientAndroidLog headerlog,
        final HttpClientAndroidLog wirelog,
        final int buffersize,
        final int fragmentSizeHint,
        final CharsetDecoder chardecoder,
        final CharsetEncoder charencoder,
        final MessageConstraints constraints,
        final ContentLengthStrategy incomingContentStrategy,
        final ContentLengthStrategy outgoingContentStrategy,
        final HttpMessageWriterFactory<HttpRequest> requestWriterFactory,
        final HttpMessageParserFactory<HttpResponse> responseParserFactory) {
    super(id, buffersize, fragmentSizeHint, chardecoder, charencoder,
            constraints, incomingContentStrategy, outgoingContentStrategy,
            requestWriterFactory, responseParserFactory);
    this.log = log;
    this.headerlog = headerlog;
    this.wire = new Wire(wirelog, id);
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public void process(final HttpRequest request, final HttpContext context)
        throws HttpException, IOException {
    Args.notNull(request, "HTTP request");

    final String method = request.getRequestLine().getMethod();
    if (method.equalsIgnoreCase("CONNECT")) {
        return;
    }

    if (!request.containsHeader(HTTP.CONN_DIRECTIVE)) {
        // Default policy is to keep connection alive
        // whenever possible
        request.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE);
    }
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
public HttpRoute determineRoute(final HttpHost target,
                                final HttpRequest request,
                                final HttpContext context)
    throws HttpException {

    Args.notNull(request, "HTTP request");

    // If we have a forced route, we can do without a target.
    HttpRoute route =
        ConnRouteParams.getForcedRoute(request.getParams());
    if (route != null) {
        return route;
    }

    // If we get here, there is no forced route.
    // So we need a target to compute a route.

    Asserts.notNull(target, "Target host");

    final InetAddress local =
        ConnRouteParams.getLocalAddress(request.getParams());
    final HttpHost proxy = determineProxy(target, request, context);

    final Scheme schm =
        this.schemeRegistry.getScheme(target.getSchemeName());
    // as it is typically used for TLS/SSL, we assume that
    // a layered scheme implies a secure connection
    final boolean secure = schm.isLayered();

    if (proxy == null) {
        route = new HttpRoute(target, local, secure);
    } else {
        route = new HttpRoute(target, local, proxy, secure);
    }
    return route;
}
 

import ch.boye.httpclientandroidlib.HttpRequest; //导入依赖的package包/类
protected boolean requestMinorVersionIsTooHighMajorVersionsMatch(final HttpRequest request) {
    final ProtocolVersion requestProtocol = request.getProtocolVersion();
    if (requestProtocol.getMajor() != HttpVersion.HTTP_1_1.getMajor()) {
        return false;
    }

    if (requestProtocol.getMinor() > HttpVersion.HTTP_1_1.getMinor()) {
        return true;
    }

    return false;
}