• CloseableHttpClient 源码


    public abstract class CloseableHttpClient implements HttpClient, Closeable {
    
        private final Log log = LogFactory.getLog(getClass());
    
        protected abstract CloseableHttpResponse doExecute(HttpHost target, HttpRequest request,
                HttpContext context) throws IOException, ClientProtocolException;
    
        /**
         * {@inheritDoc}
         */
        public CloseableHttpResponse execute(
                final HttpHost target,
                final HttpRequest request,
                final HttpContext context) throws IOException, ClientProtocolException {
            return doExecute(target, request, context);
        }
    
        /**
         * {@inheritDoc}
         */
        public CloseableHttpResponse execute(
                final HttpUriRequest request,
                final HttpContext context) throws IOException, ClientProtocolException {
            Args.notNull(request, "HTTP request");
            return doExecute(determineTarget(request), request, context);
        }
    
        private static HttpHost determineTarget(final HttpUriRequest request) throws ClientProtocolException {
            // A null target may be acceptable if there is a default target.
            // Otherwise, the null target is detected in the director.
            HttpHost target = null;
    
            final URI requestURI = request.getURI();
            if (requestURI.isAbsolute()) {
                target = URIUtils.extractHost(requestURI);
                if (target == null) {
                    throw new ClientProtocolException("URI does not specify a valid host name: "
                            + requestURI);
                }
            }
            return target;
        }
    
        /**
         * {@inheritDoc}
         */
        public CloseableHttpResponse execute(
                final HttpUriRequest request) throws IOException, ClientProtocolException {
            return execute(request, (HttpContext) null);
        }
    
        /**
         * {@inheritDoc}
         */
        public CloseableHttpResponse execute(
                final HttpHost target,
                final HttpRequest request) throws IOException, ClientProtocolException {
            return doExecute(target, request, (HttpContext) null);
        }
    
        /**
         * Executes a request using the default context and processes the
         * response using the given response handler. The content entity associated
         * with the response is fully consumed and the underlying connection is
         * released back to the connection manager automatically in all cases
         * relieving individual {@link ResponseHandler}s from having to manage
         * resource deallocation internally.
         *
         * @param request   the request to execute
         * @param responseHandler the response handler
         *
         * @return  the response object as generated by the response handler.
         * @throws IOException in case of a problem or the connection was aborted
         * @throws ClientProtocolException in case of an http protocol error
         */
        public <T> T execute(final HttpUriRequest request,
                final ResponseHandler<? extends T> responseHandler) throws IOException,
                ClientProtocolException {
            return execute(request, responseHandler, null);
        }
    
        /**
         * Executes a request using the default context and processes the
         * response using the given response handler. The content entity associated
         * with the response is fully consumed and the underlying connection is
         * released back to the connection manager automatically in all cases
         * relieving individual {@link ResponseHandler}s from having to manage
         * resource deallocation internally.
         *
         * @param request   the request to execute
         * @param responseHandler the response handler
         * @param context   the context to use for the execution, or
         *                  <code>null</code> to use the default context
         *
         * @return  the response object as generated by the response handler.
         * @throws IOException in case of a problem or the connection was aborted
         * @throws ClientProtocolException in case of an http protocol error
         */
        public <T> T execute(final HttpUriRequest request,
                final ResponseHandler<? extends T> responseHandler, final HttpContext context)
                throws IOException, ClientProtocolException {
            final HttpHost target = determineTarget(request);
            return execute(target, request, responseHandler, context);
        }
    
        /**
         * Executes a request using the default context and processes the
         * response using the given response handler. The content entity associated
         * with the response is fully consumed and the underlying connection is
         * released back to the connection manager automatically in all cases
         * relieving individual {@link ResponseHandler}s from having to manage
         * resource deallocation internally.
         *
         * @param target    the target host for the request.
         *                  Implementations may accept <code>null</code>
         *                  if they can still determine a route, for example
         *                  to a default target or by inspecting the request.
         * @param request   the request to execute
         * @param responseHandler the response handler
         *
         * @return  the response object as generated by the response handler.
         * @throws IOException in case of a problem or the connection was aborted
         * @throws ClientProtocolException in case of an http protocol error
         */
        public <T> T execute(final HttpHost target, final HttpRequest request,
                final ResponseHandler<? extends T> responseHandler) throws IOException,
                ClientProtocolException {
            return execute(target, request, responseHandler, null);
        }
    
        /**
         * Executes a request using the default context and processes the
         * response using the given response handler. The content entity associated
         * with the response is fully consumed and the underlying connection is
         * released back to the connection manager automatically in all cases
         * relieving individual {@link ResponseHandler}s from having to manage
         * resource deallocation internally.
         *
         * @param target    the target host for the request.
         *                  Implementations may accept <code>null</code>
         *                  if they can still determine a route, for example
         *                  to a default target or by inspecting the request.
         * @param request   the request to execute
         * @param responseHandler the response handler
         * @param context   the context to use for the execution, or
         *                  <code>null</code> to use the default context
         *
         * @return  the response object as generated by the response handler.
         * @throws IOException in case of a problem or the connection was aborted
         * @throws ClientProtocolException in case of an http protocol error
         */
        public <T> T execute(final HttpHost target, final HttpRequest request,
                final ResponseHandler<? extends T> responseHandler, final HttpContext context)
                throws IOException, ClientProtocolException {
            Args.notNull(responseHandler, "Response handler");
    
            final HttpResponse response = execute(target, request, context);
    
            final T result;
            try {
                result = responseHandler.handleResponse(response);
            } catch (final Exception t) {
                final HttpEntity entity = response.getEntity();
                try {
                    EntityUtils.consume(entity);
                } catch (final Exception t2) {
                    // Log this exception. The original exception is more
                    // important and will be thrown to the caller.
                    this.log.warn("Error consuming content after an exception.", t2);
                }
                if (t instanceof RuntimeException) {
                    throw (RuntimeException) t;
                }
                if (t instanceof IOException) {
                    throw (IOException) t;
                }
                throw new UndeclaredThrowableException(t);
            }
    
            // Handling the response was successful. Ensure that the content has
            // been fully consumed.
            final HttpEntity entity = response.getEntity();
            EntityUtils.consume(entity);
            return result;
        }
    
    }
  • 相关阅读:
    2015hust暑假集训 0715 F
    hust2015暑假集训 0715 c a coprime
    0714c
    hdu_1019Least Common Multiple(最小公倍数)
    hdu_1576A/B(扩展欧几里得求逆元)
    hdu_5104 Primes Problem()
    hdu_3483A Very Simple Problem(C(m,n)+快速幂矩阵)
    hdu_2604Queuing(快速幂矩阵)
    hdu_3003Pupu(快速幂)
    神奇的读入读出
  • 原文地址:https://www.cnblogs.com/pray/p/3891615.html
Copyright © 2020-2023  润新知