不会汪汪的猫咪
不会汪汪的猫咪

一个http-request的源码及改进

一个http-request的源码及改进

这个版本是基于Http-requesthttps://github.com/kevinsawicki/http-request进行升级的http-request。

进行了一下改变：

1.封装了HttpResponse,让request和response分离

2.设置了defaultTimeOut标志，可以设置默认超时时间。

3.executeHttpRequest进行返回Response,使结构更清晰。

使用方式:

HttpResponse httpResponse = HttpRequest.get("https://www.google.com").defaultTimeOut().executeHttpRequest();

String httpRet = httpResponse.body();

int code = httpResponse.code();

源码如下：

/*
     * Copyright (c) 2014 Kevin Sawicki 
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to
     * deal in the Software without restriction, including without limitation the
     * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
     * sell copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
     * IN THE SOFTWARE.
     */
    package com.github.kevinsawicki.http;

    import static java.net.HttpURLConnection.HTTP_BAD_REQUEST;
    import static java.net.HttpURLConnection.HTTP_CREATED;
    import static java.net.HttpURLConnection.HTTP_INTERNAL_ERROR;
    import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
    import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
    import static java.net.HttpURLConnection.HTTP_NOT_MODIFIED;
    import static java.net.HttpURLConnection.HTTP_OK;
    import static java.net.Proxy.Type.HTTP;

    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.Closeable;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.Flushable;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintStream;
    import java.io.Reader;
    import java.io.UnsupportedEncodingException;
    import java.io.Writer;
    import java.net.HttpURLConnection;
    import java.net.InetSocketAddress;
    import java.net.MalformedURLException;
    import java.net.Proxy;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.net.URL;
    import java.net.URLEncoder;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;
    import java.nio.charset.CharsetEncoder;
    import java.security.AccessController;
    import java.security.GeneralSecurityException;
    import java.security.PrivilegedAction;
    import java.security.SecureRandom;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.concurrent.Callable;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.zip.GZIPInputStream;

    import javax.net.ssl.HostnameVerifier;
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSession;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;

    /**
     * A fluid interface for making HTTP requests using an underlying
     * {@link HttpURLConnection} (or sub-class).
     * 

     * Each instance supports making a single request and cannot be reused for
     * further requests.
     */
    public class HttpRequest {

      /**
       * 'UTF-8' charset name
       */
      public static final String CHARSET_UTF8 = "UTF-8";

      /**
       * 'application/x-www-form-urlencoded' content type header value
       */
      public static final String CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";

      /**
       * 'application/json' content type header value
       */
      public static final String CONTENT_TYPE_JSON = "application/json";

      /**
       * 'gzip' encoding header value
       */
      public static final String ENCODING_GZIP = "gzip";

      /**
       * 'Accept' header name
       */
      public static final String HEADER_ACCEPT = "Accept";

      /**
       * 'Accept-Charset' header name
       */
      public static final String HEADER_ACCEPT_CHARSET = "Accept-Charset";

      /**
       * 'Accept-Encoding' header name
       */
      public static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";

      /**
       * 'Authorization' header name
       */
      public static final String HEADER_AUTHORIZATION = "Authorization";

      /**
       * 'Cache-Control' header name
       */
      public static final String HEADER_CACHE_CONTROL = "Cache-Control";

      /**
       * 'Content-Encoding' header name
       */
      public static final String HEADER_CONTENT_ENCODING = "Content-Encoding";

      /**
       * 'Content-Length' header name
       */
      public static final String HEADER_CONTENT_LENGTH = "Content-Length";

      /**
       * 'Content-Type' header name
       */
      public static final String HEADER_CONTENT_TYPE = "Content-Type";

      /**
       * 'Date' header name
       */
      public static final String HEADER_DATE = "Date";

      /**
       * 'ETag' header name
       */
      public static final String HEADER_ETAG = "ETag";

      /**
       * 'Expires' header name
       */
      public static final String HEADER_EXPIRES = "Expires";

      /**
       * 'If-None-Match' header name
       */
      public static final String HEADER_IF_NONE_MATCH = "If-None-Match";

      /**
       * 'Last-Modified' header name
       */
      public static final String HEADER_LAST_MODIFIED = "Last-Modified";

      /**
       * 'Location' header name
       */
      public static final String HEADER_LOCATION = "Location";

      /**
       * 'Proxy-Authorization' header name
       */
      public static final String HEADER_PROXY_AUTHORIZATION = "Proxy-Authorization";

      /**
       * 'Referer' header name
       */
      public static final String HEADER_REFERER = "Referer";

      /**
       * 'Server' header name
       */
      public static final String HEADER_SERVER = "Server";

      /**
       * 'User-Agent' header name
       */
      public static final String HEADER_USER_AGENT = "User-Agent";

      /**
       * 'DELETE' request method
       */
      public static final String METHOD_DELETE = "DELETE";

      /**
       * 'GET' request method
       */
      public static final String METHOD_GET = "GET";

      /**
       * 'HEAD' request method
       */
      public static final String METHOD_HEAD = "HEAD";

      /**
       * 'OPTIONS' options method
       */
      public static final String METHOD_OPTIONS = "OPTIONS";

      /**
       * 'POST' request method
       */
      public static final String METHOD_POST = "POST";

      /**
       * 'PUT' request method
       */
      public static final String METHOD_PUT = "PUT";

      /**
       * 'TRACE' request method
       */
      public static final String METHOD_TRACE = "TRACE";

      /**
       * 'charset' header value parameter
       */
      public static final String PARAM_CHARSET = "charset";

      private static final String BOUNDARY = "00content0boundary00";

      private static final String CONTENT_TYPE_MULTIPART = "multipart/form-data; boundary="
          + BOUNDARY;

      private static final String CRLF = "\r\n";

      private static final String[] EMPTY_STRINGS = new String[0];

      private static SSLSocketFactory TRUSTED_FACTORY;

      private static HostnameVerifier TRUSTED_VERIFIER;

      private static final int DEFAULT_READ_TIMEOUT = 5000;

      private static final int DEFAULT_CONNECT_TIMEOUT = 5000;

      private boolean defaultTimeOutFlag = false;

      private HttpResponse httpResponse;

      private static String getValidCharset(final String charset) {
        if (charset != null && charset.length() > 0)
          return charset;
        else
          return CHARSET_UTF8;
      }

      private static SSLSocketFactory getTrustedFactory()
          throws HttpRequestException {
        if (TRUSTED_FACTORY == null) {
          final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {

            public X509Certificate[] getAcceptedIssuers() {
              return new X509Certificate[0];
            }

            public void checkClientTrusted(X509Certificate[] chain, String authType) {
              // Intentionally left blank
            }

            public void checkServerTrusted(X509Certificate[] chain, String authType) {
              // Intentionally left blank
            }
          } };
          try {
            SSLContext context = SSLContext.getInstance("TLS");
            context.init(null, trustAllCerts, new SecureRandom());
            TRUSTED_FACTORY = context.getSocketFactory();
          } catch (GeneralSecurityException e) {
            IOException ioException = new IOException(
                "Security exception configuring SSL context");
            ioException.initCause(e);
            throw new HttpRequestException(ioException);
          }
        }

        return TRUSTED_FACTORY;
      }

      private static HostnameVerifier getTrustedVerifier() {
        if (TRUSTED_VERIFIER == null)
          TRUSTED_VERIFIER = new HostnameVerifier() {

            public boolean verify(String hostname, SSLSession session) {
              return true;
            }
          };

        return TRUSTED_VERIFIER;
      }

      private static StringBuilder addPathSeparator(final String baseUrl,
          final StringBuilder result) {
        // Add trailing slash if the base URL doesn't have any path segments.
        //
        // The following test is checking for the last slash not being part of
        // the protocol to host separator: '://'.
        if (baseUrl.indexOf(':') + 2 == baseUrl.lastIndexOf('/'))
          result.append('/');
        return result;
      }

      private static StringBuilder addParamPrefix(final String baseUrl,
          final StringBuilder result) {
        // Add '?' if missing and add '&' if params already exist in base url
        final int queryStart = baseUrl.indexOf('?');
        final int lastChar = result.length() - 1;
        if (queryStart == -1)
          result.append('?');
        else if (queryStart < lastChar && baseUrl.charAt(lastChar) != '&')
          result.append('&');
        return result;
      }

      private static StringBuilder addParam(final Object key, Object value,
          final StringBuilder result) {
        if (value != null && value.getClass().isArray())
          value = arrayToList(value);

        if (value instanceof Iterable) {
          Iterator iterator = ((Iterable) value).iterator();
          while (iterator.hasNext()) {
            result.append(key);
            result.append("[]=");
            Object element = iterator.next();
            if (element != null)
              result.append(element);
            if (iterator.hasNext())
              result.append("&");
          }
        } else {
          result.append(key);
          result.append("=");
          if (value != null)
            result.append(value);
        }

        return result;
      }

      /**
       * Creates {@link HttpURLConnection HTTP connections} for
       * {@link URL urls}.
       */
      public interface ConnectionFactory {
        /**
         * Open an {@link HttpURLConnection} for the specified {@link URL}.
         *
         * @throws IOException
         */
        HttpURLConnection create(URL url) throws IOException;

        /**
         * Open an {@link HttpURLConnection} for the specified {@link URL}
         * and {@link Proxy}.
         *
         * @throws IOException
         */
        HttpURLConnection create(URL url, Proxy proxy) throws IOException;

        /**
         * A {@link ConnectionFactory} which uses the built-in
         * {@link URL#openConnection()}
         */
        ConnectionFactory DEFAULT = new ConnectionFactory() {
          public HttpURLConnection create(URL url) throws IOException {
            return (HttpURLConnection) url.openConnection();
          }

          public HttpURLConnection create(URL url, Proxy proxy) throws IOException {
            return (HttpURLConnection) url.openConnection(proxy);
          }
        };
      }

      private static ConnectionFactory CONNECTION_FACTORY = ConnectionFactory.DEFAULT;

      /**
       * Specify the {@link ConnectionFactory} used to create new requests.
       */
      public static void setConnectionFactory(final ConnectionFactory connectionFactory) {
        if (connectionFactory == null)
          CONNECTION_FACTORY = ConnectionFactory.DEFAULT;
        else
          CONNECTION_FACTORY = connectionFactory;
      }

      /**
       * Callback interface for reporting upload progress for a request.
       */
      public interface UploadProgress {
        /**
         * Callback invoked as data is uploaded by the request.
         *
         * @param uploaded The number of bytes already uploaded
         * @param total The total number of bytes that will be uploaded or -1 if
         *              the length is unknown.
         */
        void onUpload(long uploaded, long total);

        UploadProgress DEFAULT = new UploadProgress() {
          public void onUpload(long uploaded, long total) {
          }
        };
      }

      /**
       * 

       * Encodes and decodes to and from Base64 notation.
       * 

       * 

       * I am placing this code in the Public Domain. Do with it as you will. This
       * software comes with no guarantees or warranties but with plenty of
       * well-wishing instead! Please visit http://iharder.net/base64 periodically
       * to check for updates or to contribute improvements.
       * 

       *
       * @author Robert Harder
       * @author [email protected]
       * @version 2.3.7
       */
      public static class Base64 {

        /** The equals sign (=) as a byte. */
        private final static byte EQUALS_SIGN = (byte) '=';

        /** Preferred encoding. */
        private final static String PREFERRED_ENCODING = "US-ASCII";

        /** The 64 valid Base64 values. */
        private final static byte[] _STANDARD_ALPHABET = { (byte) 'A', (byte) 'B',
            (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F', (byte) 'G', (byte) 'H',
            (byte) 'I', (byte) 'J', (byte) 'K', (byte) 'L', (byte) 'M', (byte) 'N',
            (byte) 'O', (byte) 'P', (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T',
            (byte) 'U', (byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z',
            (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e', (byte) 'f',
            (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j', (byte) 'k', (byte) 'l',
            (byte) 'm', (byte) 'n', (byte) 'o', (byte) 'p', (byte) 'q', (byte) 'r',
            (byte) 's', (byte) 't', (byte) 'u', (byte) 'v', (byte) 'w', (byte) 'x',
            (byte) 'y', (byte) 'z', (byte) '0', (byte) '1', (byte) '2', (byte) '3',
            (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8', (byte) '9',
            (byte) '+', (byte) '/' };

        /** Defeats instantiation. */
        private Base64() {
        }

        /**
         * 

         * Encodes up to three bytes of the array source and writes the
         * resulting four Base64 bytes to destination. The source and
         * destination arrays can be manipulated anywhere along their length by
         * specifying srcOffset and destOffset. This method
         * does not check to make sure your arrays are large enough to accomodate
         * srcOffset + 3 for the source array or
         * destOffset + 4 for the destination array. The
         * actual number of significant bytes in your array is given by
         * numSigBytes.
         * 

         * 

         * This is the lowest level of the encoding methods with all possible
         * parameters.
         * 

         *
         * @param source
         *          the array to convert
         * @param srcOffset
         *          the index where conversion begins
         * @param numSigBytes
         *          the number of significant bytes in your array
         * @param destination
         *          the array to hold the conversion
         * @param destOffset
         *          the index where output will be put
         * @return the destination array
         * @since 1.3
         */
        private static byte[] encode3to4(byte[] source, int srcOffset,
            int numSigBytes, byte[] destination, int destOffset) {

          byte[] ALPHABET = _STANDARD_ALPHABET;

          int inBuff = (numSigBytes > 0 ? ((source[srcOffset] << 24) >>> 8) : 0)
              | (numSigBytes > 1 ? ((source[srcOffset + 1] << 24) >>> 16) : 0)
              | (numSigBytes > 2 ? ((source[srcOffset + 2] << 24) >>> 24) : 0);

          switch (numSigBytes) {
          case 3:
            destination[destOffset] = ALPHABET[(inBuff >>> 18)];
            destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
            destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f];
            destination[destOffset + 3] = ALPHABET[(inBuff) & 0x3f];
            return destination;

          case 2:
            destination[destOffset] = ALPHABET[(inBuff >>> 18)];
            destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
            destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f];
            destination[destOffset + 3] = EQUALS_SIGN;
            return destination;

          case 1:
            destination[destOffset] = ALPHABET[(inBuff >>> 18)];
            destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
            destination[destOffset + 2] = EQUALS_SIGN;
            destination[destOffset + 3] = EQUALS_SIGN;
            return destination;

          default:
            return destination;
          }
        }

        /**
         * Encode string as a byte array in Base64 annotation.
         *
         * @param string
         * @return The Base64-encoded data as a string
         */
        public static String encode(String string) {
          byte[] bytes;
          try {
            bytes = string.getBytes(PREFERRED_ENCODING);
          } catch (UnsupportedEncodingException e) {
            bytes = string.getBytes();
          }
          return encodeBytes(bytes);
        }

        /**
         * Encodes a byte array into Base64 notation.
         *
         * @param source
         *          The data to convert
         * @return The Base64-encoded data as a String
         * @throws NullPointerException
         *           if source array is null
         * @throws IllegalArgumentException
         *           if source array, offset, or length are invalid
         * @since 2.0
         */
        public static String encodeBytes(byte[] source) {
          return encodeBytes(source, 0, source.length);
        }

        /**
         * Encodes a byte array into Base64 notation.
         *
         * @param source
         *          The data to convert
         * @param off
         *          Offset in array where conversion should begin
         * @param len
         *          Length of data to convert
         * @return The Base64-encoded data as a String
         * @throws NullPointerException
         *           if source array is null
         * @throws IllegalArgumentException
         *           if source array, offset, or length are invalid
         * @since 2.0
         */
        public static String encodeBytes(byte[] source, int off, int len) {
          byte[] encoded = encodeBytesToBytes(source, off, len);
          try {
            return new String(encoded, PREFERRED_ENCODING);
          } catch (UnsupportedEncodingException uue) {
            return new String(encoded);
          }
        }

        /**
         * Similar to {@link #encodeBytes(byte[], int, int)} but returns a byte
         * array instead of instantiating a String. This is more efficient if you're
         * working with I/O streams and have large data sets to encode.
         *
         *
         * @param source
         *          The data to convert
         * @param off
         *          Offset in array where conversion should begin
         * @param len
         *          Length of data to convert
         * @return The Base64-encoded data as a String if there is an error
         * @throws NullPointerException
         *           if source array is null
         * @throws IllegalArgumentException
         *           if source array, offset, or length are invalid
         * @since 2.3.1
         */
        public static byte[] encodeBytesToBytes(byte[] source, int off, int len) {

          if (source == null)
            throw new NullPointerException("Cannot serialize a null array.");

          if (off < 0)
            throw new IllegalArgumentException("Cannot have negative offset: "
                + off);

          if (len < 0)
            throw new IllegalArgumentException("Cannot have length offset: " + len);

          if (off + len > source.length)
            throw new IllegalArgumentException(
                String
                    .format(
                        "Cannot have offset of %d and length of %d with array of length %d",
                        off, len, source.length));

          // Bytes needed for actual encoding
          int encLen = (len / 3) * 4 + (len % 3 > 0 ? 4 : 0);

          byte[] outBuff = new byte[encLen];

          int d = 0;
          int e = 0;
          int len2 = len - 2;
          for (; d < len2; d += 3, e += 4)
            encode3to4(source, d + off, 3, outBuff, e);

          if (d < len) {
            encode3to4(source, d + off, len - d, outBuff, e);
            e += 4;
          }

          if (e <= outBuff.length - 1) {
            byte[] finalOut = new byte[e];
            System.arraycopy(outBuff, 0, finalOut, 0, e);
            return finalOut;
          } else
            return outBuff;
        }
      }

      /**
       * HTTP request exception whose cause is always an {@link IOException}
       */
      public static class HttpRequestException extends RuntimeException {

        private static final long serialVersionUID = -1170466989781746231L;

        /**
         * Create a new HttpRequestException with the given cause
         *
         * @param cause
         */
        public HttpRequestException(final IOException cause) {
          super(cause);
        }

        /**
         * Get {@link IOException} that triggered this request exception
         *
         * @return {@link IOException} cause
         */
        @Override
        public IOException getCause() {
          return (IOException) super.getCause();
        }
      }

      /**
       * Operation that handles executing a callback once complete and handling
       * nested exceptions
       *
       * @param 
       */
      protected static abstract class Operation implements Callable {

        /**
         * Run operation
         *
         * @return result
         * @throws HttpRequestException
         * @throws IOException
         */
        protected abstract V run() throws HttpRequestException, IOException;

        /**
         * Operation complete callback
         *
         * @throws IOException
         */
        protected abstract void done() throws IOException;

        public V call() throws HttpRequestException {
          boolean thrown = false;
          try {
            return run();
          } catch (HttpRequestException e) {
            thrown = true;
            throw e;
          } catch (IOException e) {
            thrown = true;
            throw new HttpRequestException(e);
          } finally {
            try {
              done();
            } catch (IOException e) {
              if (!thrown)
                throw new HttpRequestException(e);
            }
          }
        }
      }

      /**
       * Class that ensures a {@link Closeable} gets closed with proper exception
       * handling.
       *
       * @param 
       */
      protected static abstract class CloseOperation extends Operation {

        private final Closeable closeable;

        private final boolean ignoreCloseExceptions;

        /**
         * Create closer for operation
         *
         * @param closeable
         * @param ignoreCloseExceptions
         */
        protected CloseOperation(final Closeable closeable,
            final boolean ignoreCloseExceptions) {
          this.closeable = closeable;
          this.ignoreCloseExceptions = ignoreCloseExceptions;
        }

        @Override
        protected void done() throws IOException {
          if (closeable instanceof Flushable)
            ((Flushable) closeable).flush();
          if (ignoreCloseExceptions)
            try {
              closeable.close();
            } catch (IOException e) {
              // Ignored
            }
          else
            closeable.close();
        }
      }

      /**
       * Class that and ensures a {@link Flushable} gets flushed with proper
       * exception handling.
       *
       * @param 
       */
      protected static abstract class FlushOperation extends Operation {

        private final Flushable flushable;

        /**
         * Create flush operation
         *
         * @param flushable
         */
        protected FlushOperation(final Flushable flushable) {
          this.flushable = flushable;
        }

        @Override
        protected void done() throws IOException {
          flushable.flush();
        }
      }

      /**
       * Request output stream
       */
      public static class RequestOutputStream extends BufferedOutputStream {

        private final CharsetEncoder encoder;

        /**
         * Create request output stream
         *
         * @param stream
         * @param charset
         * @param bufferSize
         */
        public RequestOutputStream(final OutputStream stream, final String charset,
            final int bufferSize) {
          super(stream, bufferSize);

          encoder = Charset.forName(getValidCharset(charset)).newEncoder();
        }

        /**
         * Write string to stream
         *
         * @param value
         * @return this stream
         * @throws IOException
         */
        public RequestOutputStream write(final String value) throws IOException {
          final ByteBuffer bytes = encoder.encode(CharBuffer.wrap(value));

          super.write(bytes.array(), 0, bytes.limit());

          return this;
        }
      }

      /**
       * Represents array of any type as list of objects so we can easily iterate over it
       * @param array of elements
       * @return list with the same elements
       */
      private static List arrayToList(final Object array) {
        if (array instanceof Object[])
          return Arrays.asList((Object[]) array);

        List result = new ArrayList();
        // Arrays of the primitive types can't be cast to array of Object, so this:
        if (array instanceof int[])
          for (int value : (int[]) array) result.add(value);
        else if (array instanceof boolean[])
          for (boolean value : (boolean[]) array) result.add(value);
        else if (array instanceof long[])
          for (long value : (long[]) array) result.add(value);
        else if (array instanceof float[])
          for (float value : (float[]) array) result.add(value);
        else if (array instanceof double[])
          for (double value : (double[]) array) result.add(value);
        else if (array instanceof short[])
          for (short value : (short[]) array) result.add(value);
        else if (array instanceof byte[])
          for (byte value : (byte[]) array) result.add(value);
        else if (array instanceof char[])
          for (char value : (char[]) array) result.add(value);
        return result;
      }

      /**
       * Encode the given URL as an ASCII {@link String}
       * 

       * This method ensures the path and query segments of the URL are properly
       * encoded such as ' ' characters being encoded to '%20' or any UTF-8
       * characters that are non-ASCII. No encoding of URLs is done by default by
       * the {@link HttpRequest} constructors and so if URL encoding is needed this
       * method should be called before calling the {@link HttpRequest} constructor.
       *
       * @param url
       * @return encoded URL
       * @throws HttpRequestException
       */
      public static String encode(final CharSequence url)
          throws HttpRequestException {
        URL parsed;
        try {
          parsed = new URL(url.toString());
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }

        String host = parsed.getHost();
        int port = parsed.getPort();
        if (port != -1)
          host = host + ':' + Integer.toString(port);

        try {
          String encoded = new URI(parsed.getProtocol(), host, parsed.getPath(),
              parsed.getQuery(), null).toASCIIString();
          int paramsStart = encoded.indexOf('?');
          if (paramsStart > 0 && paramsStart + 1 < encoded.length())
            encoded = encoded.substring(0, paramsStart + 1)
                      + encoded.substring(paramsStart + 1).replace("+", "%2B");
          return encoded;
        } catch (URISyntaxException e) {
          IOException io = new IOException("Parsing URI failed");
          io.initCause(e);
          throw new HttpRequestException(io);
        }
      }

      /**
       * Append given map as query parameters to the base URL
       * 

       * Each map entry's key will be a parameter name and the value's
       * {@link Object#toString()} will be the parameter value.
       *
       * @param url
       * @param params
       * @return URL with appended query params
       */
      public static String append(final CharSequence url, final Map params) {
        final String baseUrl = url.toString();
        if (params == null || params.isEmpty())
          return baseUrl;

        final StringBuilder result = new StringBuilder(baseUrl);

        addPathSeparator(baseUrl, result);
        addParamPrefix(baseUrl, result);

        Entry entry;
        Iterator iterator = params.entrySet().iterator();
        entry = (Entry) iterator.next();
        addParam(entry.getKey().toString(), entry.getValue(), result);

        while (iterator.hasNext()) {
          result.append('&');
          entry = (Entry) iterator.next();
          addParam(entry.getKey().toString(), entry.getValue(), result);
        }

        return result.toString();
      }

      /**
       * Append given name/value pairs as query parameters to the base URL
       * 

       * The params argument is interpreted as a sequence of name/value pairs so the
       * given number of params must be divisible by 2.
       *
       * @param url
       * @param params
       *          name/value pairs
       * @return URL with appended query params
       */
      public static String append(final CharSequence url, final Object... params) {
        final String baseUrl = url.toString();
        if (params == null || params.length == 0)
          return baseUrl;

        if (params.length % 2 != 0)
          throw new IllegalArgumentException(
              "Must specify an even number of parameter names/values");

        final StringBuilder result = new StringBuilder(baseUrl);

        addPathSeparator(baseUrl, result);
        addParamPrefix(baseUrl, result);

        addParam(params[0], params[1], result);

        for (int i = 2; i < params.length; i += 2) {
          result.append('&');
          addParam(params[i], params[i + 1], result);
        }

        return result.toString();
      }

      /**
       * Start a 'GET' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest get(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_GET);
      }

      /**
       * Start a 'GET' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest get(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_GET);
      }

      /**
       * Start a 'GET' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param params
       *          The query parameters to include as part of the baseUrl
       * @param encode
       *          true to encode the full URL
       *
       * @see #append(CharSequence, Map)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest get(final CharSequence baseUrl,
          final Map params, final boolean encode) {
        String url = append(baseUrl, params);
        return get(encode ? encode(url) : url);
      }

      /**
       * Start a 'GET' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param encode
       *          true to encode the full URL
       * @param params
       *          the name/value query parameter pairs to include as part of the
       *          baseUrl
       *
       * @see #append(CharSequence, Object...)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest get(final CharSequence baseUrl,
          final boolean encode, final Object... params) {
        String url = append(baseUrl, params);
        return get(encode ? encode(url) : url);
      }

      /**
       * Start a 'POST' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest post(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_POST);
      }

      /**
       * Start a 'POST' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest post(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_POST);
      }

      /**
       * Start a 'POST' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param params
       *          the query parameters to include as part of the baseUrl
       * @param encode
       *          true to encode the full URL
       *
       * @see #append(CharSequence, Map)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest post(final CharSequence baseUrl,
          final Map params, final boolean encode) {
        String url = append(baseUrl, params);
        return post(encode ? encode(url) : url);
      }

      /**
       * Start a 'POST' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param encode
       *          true to encode the full URL
       * @param params
       *          the name/value query parameter pairs to include as part of the
       *          baseUrl
       *
       * @see #append(CharSequence, Object...)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest post(final CharSequence baseUrl,
          final boolean encode, final Object... params) {
        String url = append(baseUrl, params);
        return post(encode ? encode(url) : url);
      }

      /**
       * Start a 'PUT' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest put(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_PUT);
      }

      /**
       * Start a 'PUT' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest put(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_PUT);
      }

      /**
       * Start a 'PUT' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param params
       *          the query parameters to include as part of the baseUrl
       * @param encode
       *          true to encode the full URL
       *
       * @see #append(CharSequence, Map)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest put(final CharSequence baseUrl,
          final Map params, final boolean encode) {
        String url = append(baseUrl, params);
        return put(encode ? encode(url) : url);
      }

      /**
       * Start a 'PUT' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param encode
       *          true to encode the full URL
       * @param params
       *          the name/value query parameter pairs to include as part of the
       *          baseUrl
       *
       * @see #append(CharSequence, Object...)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest put(final CharSequence baseUrl,
          final boolean encode, final Object... params) {
        String url = append(baseUrl, params);
        return put(encode ? encode(url) : url);
      }

      /**
       * Start a 'DELETE' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest delete(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_DELETE);
      }

      /**
       * Start a 'DELETE' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest delete(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_DELETE);
      }

      /**
       * Start a 'DELETE' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param params
       *          The query parameters to include as part of the baseUrl
       * @param encode
       *          true to encode the full URL
       *
       * @see #append(CharSequence, Map)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest delete(final CharSequence baseUrl,
          final Map params, final boolean encode) {
        String url = append(baseUrl, params);
        return delete(encode ? encode(url) : url);
      }

      /**
       * Start a 'DELETE' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param encode
       *          true to encode the full URL
       * @param params
       *          the name/value query parameter pairs to include as part of the
       *          baseUrl
       *
       * @see #append(CharSequence, Object...)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest delete(final CharSequence baseUrl,
          final boolean encode, final Object... params) {
        String url = append(baseUrl, params);
        return delete(encode ? encode(url) : url);
      }

      /**
       * Start a 'HEAD' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest head(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_HEAD);
      }

      /**
       * Start a 'HEAD' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest head(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_HEAD);
      }

      /**
       * Start a 'HEAD' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param params
       *          The query parameters to include as part of the baseUrl
       * @param encode
       *          true to encode the full URL
       *
       * @see #append(CharSequence, Map)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest head(final CharSequence baseUrl,
          final Map params, final boolean encode) {
        String url = append(baseUrl, params);
        return head(encode ? encode(url) : url);
      }

      /**
       * Start a 'GET' request to the given URL along with the query params
       *
       * @param baseUrl
       * @param encode
       *          true to encode the full URL
       * @param params
       *          the name/value query parameter pairs to include as part of the
       *          baseUrl
       *
       * @see #append(CharSequence, Object...)
       * @see #encode(CharSequence)
       *
       * @return request
       */
      public static HttpRequest head(final CharSequence baseUrl,
          final boolean encode, final Object... params) {
        String url = append(baseUrl, params);
        return head(encode ? encode(url) : url);
      }

      /**
       * Start an 'OPTIONS' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest options(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_OPTIONS);
      }

      /**
       * Start an 'OPTIONS' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest options(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_OPTIONS);
      }

      /**
       * Start a 'TRACE' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest trace(final CharSequence url)
          throws HttpRequestException {
        return new HttpRequest(url, METHOD_TRACE);
      }

      /**
       * Start a 'TRACE' request to the given URL
       *
       * @param url
       * @return request
       * @throws HttpRequestException
       */
      public static HttpRequest trace(final URL url) throws HttpRequestException {
        return new HttpRequest(url, METHOD_TRACE);
      }

      /**
       * Set the 'http.keepAlive' property to the given value.
       * 

       * This setting will apply to all requests.
       *
       * @param keepAlive
       */
      public static void keepAlive(final boolean keepAlive) {
        setProperty("http.keepAlive", Boolean.toString(keepAlive));
      }

      /**
       * Set the 'http.maxConnections' property to the given value.
       * 

       * This setting will apply to all requests.
       *
       * @param maxConnections
       */
      public static void maxConnections(final int maxConnections) {
        setProperty("http.maxConnections", Integer.toString(maxConnections));
      }

      /**
       * Set the 'http.proxyHost' and 'https.proxyHost' properties to the given host
       * value.
       * 

       * This setting will apply to all requests.
       *
       * @param host
       */
      public static void proxyHost(final String host) {
        setProperty("http.proxyHost", host);
        setProperty("https.proxyHost", host);
      }

      /**
       * Set the 'http.proxyPort' and 'https.proxyPort' properties to the given port
       * number.
       * 

       * This setting will apply to all requests.
       *
       * @param port
       */
      public static void proxyPort(final int port) {
        final String portValue = Integer.toString(port);
        setProperty("http.proxyPort", portValue);
        setProperty("https.proxyPort", portValue);
      }

      /**
       * Set the 'http.nonProxyHosts' property to the given host values.
       * 

       * Hosts will be separated by a '|' character.
       * 

       * This setting will apply to all requests.
       *
       * @param hosts
       */
      public static void nonProxyHosts(final String... hosts) {
        if (hosts != null && hosts.length > 0) {
          StringBuilder separated = new StringBuilder();
          int last = hosts.length - 1;
          for (int i = 0; i < last; i++)
            separated.append(hosts[i]).append('|');
          separated.append(hosts[last]);
          setProperty("http.nonProxyHosts", separated.toString());
        } else
          setProperty("http.nonProxyHosts", null);
      }

      /**
       * Set property to given value.
       * 

       * Specifying a null value will cause the property to be cleared
       *
       * @param name
       * @param value
       * @return previous value
       */
      private static String setProperty(final String name, final String value) {
        final PrivilegedAction action;
        if (value != null)
          action = new PrivilegedAction() {

            public String run() {
              return System.setProperty(name, value);
            }
          };
        else
          action = new PrivilegedAction() {

            public String run() {
              return System.clearProperty(name);
            }
          };
        return AccessController.doPrivileged(action);
      }

      private HttpURLConnection connection = null;

      private final URL url;

      private final String requestMethod;

      private RequestOutputStream output;

      private boolean multipart;

      private boolean form;

      private boolean ignoreCloseExceptions = true;

      private boolean uncompress = false;

      private int bufferSize = 8192;

      private long totalSize = -1;

      private long totalWritten = 0;

      private String httpProxyHost;

      private int httpProxyPort;

      private UploadProgress progress = UploadProgress.DEFAULT;

      /**
       * Create HTTP connection wrapper
       *
       * @param url Remote resource URL.
       * @param method HTTP request method (e.g., "GET", "POST").
       * @throws HttpRequestException
       */
      public HttpRequest(final CharSequence url, final String method)
          throws HttpRequestException {
        try {
          this.url = new URL(url.toString());
        } catch (MalformedURLException e) {
          throw new HttpRequestException(e);
        }
        this.requestMethod = method;
      }

      /**
       * Create HTTP connection wrapper
       *
       * @param url Remote resource URL.
       * @param method HTTP request method (e.g., "GET", "POST").
       * @throws HttpRequestException
       */
      public HttpRequest(final URL url, final String method)
          throws HttpRequestException {
        this.url = url;
        this.requestMethod = method;
      }

      private Proxy createProxy() {
        return new Proxy(HTTP, new InetSocketAddress(httpProxyHost, httpProxyPort));
      }

      private HttpURLConnection createConnection() {
        try {
          final HttpURLConnection connection;
          if (httpProxyHost != null)
            connection = CONNECTION_FACTORY.create(url, createProxy());
          else
            connection = CONNECTION_FACTORY.create(url);
          connection.setRequestMethod(requestMethod);
          return connection;
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
      }

      @Override
      public String toString() {
        return method() + ' ' + url();
      }

      /**
       * Get underlying connection
       *
       * @return connection
       */
      public HttpURLConnection getConnection() {
        if (connection == null)
          connection = createConnection();
        return connection;
      }

      /**
       * Set whether or not to ignore exceptions that occur from calling
       * {@link Closeable#close()}
       * 

       * The default value of this setting is true
       *
       * @param ignore
       * @return this request
       */
      public HttpRequest ignoreCloseExceptions(final boolean ignore) {
        ignoreCloseExceptions = ignore;
        return this;
      }

      /**
       * Get whether or not exceptions thrown by {@link Closeable#close()} are
       * ignored
       *
       * @return true if ignoring, false if throwing
       */
      public boolean ignoreCloseExceptions() {
        return ignoreCloseExceptions;
      }

      /**
       * Disconnect the connection
       *
       * @return this request
       */
      public HttpRequest disconnect() {
        getConnection().disconnect();
        return this;
      }

      /**
       * Set chunked streaming mode to the given size
       *
       * @param size
       * @return this request
       */
      public HttpRequest chunk(final int size) {
        getConnection().setChunkedStreamingMode(size);
        return this;
      }

      /**
       * Set the size used when buffering and copying between streams
       * 

       * This size is also used for send and receive buffers created for both char
       * and byte arrays
       * 

       * The default buffer size is 8,192 bytes
       *
       * @param size
       * @return this request
       */
      public HttpRequest bufferSize(final int size) {
        if (size < 1)
          throw new IllegalArgumentException("Size must be greater than zero");
        bufferSize = size;
        return this;
      }

      /**
       * Get the configured buffer size
       * 

       * The default buffer size is 8,192 bytes
       *
       * @return buffer size
       */
      public int bufferSize() {
        return bufferSize;
      }

      /**
       * Set whether or not the response body should be automatically uncompressed
       * when read from.
       * 

       * This will only affect requests that have the 'Content-Encoding' response
       * header set to 'gzip'.
       * 

       * This causes all receive methods to use a {@link GZIPInputStream} when
       * applicable so that higher level streams and readers can read the data
       * uncompressed.
       * 

       * Setting this option does not cause any request headers to be set
       * automatically so {@link #acceptGzipEncoding()} should be used in
       * conjunction with this setting to tell the server to gzip the response.
       *
       * @param uncompress
       * @return this request
       */
      public HttpRequest uncompress(final boolean uncompress) {
        this.uncompress = uncompress;
        return this;
      }


      /**
       * Set read timeout on connection to given value
       *
       * @param timeout
       * @return this request
       */
      public HttpRequest readTimeout(final int timeout) {
        getConnection().setReadTimeout(timeout);
        return this;
      }

      /**
       * Set connect timeout on connection to given value
       *
       * @param timeout
       * @return this request
       */
      public HttpRequest connectTimeout(final int timeout) {
        getConnection().setConnectTimeout(timeout);
        return this;
      }

      /**
       * Set header name to given value
       *
       * @param name
       * @param value
       * @return this request
       */
      public HttpRequest header(final String name, final String value) {
        getConnection().setRequestProperty(name, value);
        return this;
      }

      /**
       * Set header name to given value
       *
       * @param name
       * @param value
       * @return this request
       */
      public HttpRequest header(final String name, final Number value) {
        return header(name, value != null ? value.toString() : null);
      }

      /**
       * Set all headers found in given map where the keys are the header names and
       * the values are the header values
       *
       * @param headers
       * @return this request
       */
      public HttpRequest headers(final Map headers) {
        if (!headers.isEmpty())
          for (Entry header : headers.entrySet())
            header(header);
        return this;
      }

      /**
       * Set header to have given entry's key as the name and value as the value
       *
       * @param header
       * @return this request
       */
      public HttpRequest header(final Entry header) {
        return header(header.getKey(), header.getValue());
      }

      /**
       * Get parameter values from header value
       *
       * @param header
       * @return parameter value or null if none
       */
      protected Map getParams(final String header) {
        if (header == null || header.length() == 0)
          return Collections.emptyMap();

        final int headerLength = header.length();
        int start = header.indexOf(';') + 1;
        if (start == 0 || start == headerLength)
          return Collections.emptyMap();

        int end = header.indexOf(';', start);
        if (end == -1)
          end = headerLength;

        Map params = new LinkedHashMap();
        while (start < end) {
          int nameEnd = header.indexOf('=', start);
          if (nameEnd != -1 && nameEnd < end) {
            String name = header.substring(start, nameEnd).trim();
            if (name.length() > 0) {
              String value = header.substring(nameEnd + 1, end).trim();
              int length = value.length();
              if (length != 0)
                if (length > 2 && '"' == value.charAt(0)
                    && '"' == value.charAt(length - 1))
                  params.put(name, value.substring(1, length - 1));
                else
                  params.put(name, value);
            }
          }

          start = end + 1;
          end = header.indexOf(';', start);
          if (end == -1)
            end = headerLength;
        }

        return params;
      }

      /**
       * Get parameter value from header value
       *
       * @param value
       * @param paramName
       * @return parameter value or null if none
       */
      protected String getParam(final String value, final String paramName) {
        if (value == null || value.length() == 0)
          return null;

        final int length = value.length();
        int start = value.indexOf(';') + 1;
        if (start == 0 || start == length)
          return null;

        int end = value.indexOf(';', start);
        if (end == -1)
          end = length;

        while (start < end) {
          int nameEnd = value.indexOf('=', start);
          if (nameEnd != -1 && nameEnd < end
              && paramName.equals(value.substring(start, nameEnd).trim())) {
            String paramValue = value.substring(nameEnd + 1, end).trim();
            int valueLength = paramValue.length();
            if (valueLength != 0)
              if (valueLength > 2 && '"' == paramValue.charAt(0)
                  && '"' == paramValue.charAt(valueLength - 1))
                return paramValue.substring(1, valueLength - 1);
              else
                return paramValue;
          }

          start = end + 1;
          end = value.indexOf(';', start);
          if (end == -1)
            end = length;
        }

        return null;
      }


      /**
       * Set the 'User-Agent' header to given value
       *
       * @param userAgent
       * @return this request
       */
      public HttpRequest userAgent(final String userAgent) {
        return header(HEADER_USER_AGENT, userAgent);
      }

      /**
       * Set the 'Referer' header to given value
       *
       * @param referer
       * @return this request
       */
      public HttpRequest referer(final String referer) {
        return header(HEADER_REFERER, referer);
      }

      /**
       * Set value of {@link HttpURLConnection#setUseCaches(boolean)}
       *
       * @param useCaches
       * @return this request
       */
      public HttpRequest useCaches(final boolean useCaches) {
        getConnection().setUseCaches(useCaches);
        return this;
      }

      /**
       * Set the 'Accept-Encoding' header to given value
       *
       * @param acceptEncoding
       * @return this request
       */
      public HttpRequest acceptEncoding(final String acceptEncoding) {
        return header(HEADER_ACCEPT_ENCODING, acceptEncoding);
      }

      /**
       * Set the 'Accept-Encoding' header to 'gzip'
       *
       * @see #uncompress(boolean)
       * @return this request
       */
      public HttpRequest acceptGzipEncoding() {
        return acceptEncoding(ENCODING_GZIP);
      }

      /**
       * Set the 'Accept-Charset' header to given value
       *
       * @param acceptCharset
       * @return this request
       */
      public HttpRequest acceptCharset(final String acceptCharset) {
        return header(HEADER_ACCEPT_CHARSET, acceptCharset);
      }

      /**
       * Set the 'Authorization' header to given value
       *
       * @param authorization
       * @return this request
       */
      public HttpRequest authorization(final String authorization) {
        return header(HEADER_AUTHORIZATION, authorization);
      }

      /**
       * Set the 'Proxy-Authorization' header to given value
       *
       * @param proxyAuthorization
       * @return this request
       */
      public HttpRequest proxyAuthorization(final String proxyAuthorization) {
        return header(HEADER_PROXY_AUTHORIZATION, proxyAuthorization);
      }

      /**
       * Set the 'Authorization' header to given values in Basic authentication
       * format
       *
       * @param name
       * @param password
       * @return this request
       */
      public HttpRequest basic(final String name, final String password) {
        return authorization("Basic " + Base64.encode(name + ':' + password));
      }

      /**
       * Set the 'Proxy-Authorization' header to given values in Basic authentication
       * format
       *
       * @param name
       * @param password
       * @return this request
       */
      public HttpRequest proxyBasic(final String name, final String password) {
        return proxyAuthorization("Basic " + Base64.encode(name + ':' + password));
      }

      /**
       * Set the 'If-Modified-Since' request header to the given value
       *
       * @param ifModifiedSince
       * @return this request
       */
      public HttpRequest ifModifiedSince(final long ifModifiedSince) {
        getConnection().setIfModifiedSince(ifModifiedSince);
        return this;
      }

      /**
       * Set the 'If-None-Match' request header to the given value
       *
       * @param ifNoneMatch
       * @return this request
       */
      public HttpRequest ifNoneMatch(final String ifNoneMatch) {
        return header(HEADER_IF_NONE_MATCH, ifNoneMatch);
      }

      /**
       * Set the 'Content-Type' request header to the given value
       *
       * @param contentType
       * @return this request
       */
      public HttpRequest contentType(final String contentType) {
        return contentType(contentType, null);
      }

      /**
       * Set the 'Content-Type' request header to the given value and charset
       *
       * @param contentType
       * @param charset
       * @return this request
       */
      public HttpRequest contentType(final String contentType, final String charset) {
        if (charset != null && charset.length() > 0) {
          final String separator = "; " + PARAM_CHARSET + '=';
          return header(HEADER_CONTENT_TYPE, contentType + separator + charset);
        } else
          return header(HEADER_CONTENT_TYPE, contentType);
      }


      /**
       * Set the 'Content-Length' request header to the given value
       *
       * @param contentLength
       * @return this request
       */
      public HttpRequest contentLength(final String contentLength) {
        return contentLength(Integer.parseInt(contentLength));
      }

      /**
       * Set the 'Content-Length' request header to the given value
       *
       * @param contentLength
       * @return this request
       */
      public HttpRequest contentLength(final int contentLength) {
        getConnection().setFixedLengthStreamingMode(contentLength);
        return this;
      }

      /**
       * Set the 'Accept' header to given value
       *
       * @param accept
       * @return this request
       */
      public HttpRequest accept(final String accept) {
        return header(HEADER_ACCEPT, accept);
      }

      /**
       * Set the 'Accept' header to 'application/json'
       *
       * @return this request
       */
      public HttpRequest acceptJson() {
        return accept(CONTENT_TYPE_JSON);
      }

      /**
       * Copy from input stream to output stream
       *
       * @param input
       * @param output
       * @return this request
       * @throws IOException
       */
      protected HttpResponse copy(final InputStream input, final OutputStream output)
          throws IOException {
        return new CloseOperation(input, ignoreCloseExceptions) {

          @Override
          public HttpResponse run() throws IOException {
            final byte[] buffer = new byte[bufferSize];
            int read;
            while ((read = input.read(buffer)) != -1) {
              output.write(buffer, 0, read);
              totalWritten += read;
              progress.onUpload(totalWritten, totalSize);
            }
            return HttpRequest.this.httpResponse;
          }
        }.call();
      }

      /**
       * Copy from reader to writer
       *
       * @param input
       * @param output
       * @return this request
       * @throws IOException
       */
      protected HttpRequest copy(final Reader input, final Writer output)
          throws IOException {
        return new CloseOperation(input, ignoreCloseExceptions) {

          @Override
          public HttpRequest run() throws IOException {
            final char[] buffer = new char[bufferSize];
            int read;
            while ((read = input.read(buffer)) != -1) {
              output.write(buffer, 0, read);
              totalWritten += read;
              progress.onUpload(totalWritten, -1);
            }
            return HttpRequest.this;
          }
        }.call();
      }

      /**
       * Set the UploadProgress callback for this request
       *
       * @param callback
       * @return this request
       */
      public HttpRequest progress(final UploadProgress callback) {
        if (callback == null)
          progress = UploadProgress.DEFAULT;
        else
          progress = callback;
        return this;
      }

      private HttpRequest incrementTotalSize(final long size) {
        if (totalSize == -1)
          totalSize = 0;
        totalSize += size;
        return this;
      }




      /**
       * Open output stream
       *
       * @return this request
       * @throws IOException
       */
      protected HttpRequest openOutput() throws IOException {
        if (output != null)
          return this;
        getConnection().setDoOutput(true);
        final String charset = getParam(
            getConnection().getRequestProperty(HEADER_CONTENT_TYPE), PARAM_CHARSET);
        output = new RequestOutputStream(getConnection().getOutputStream(), charset,
            bufferSize);
        return this;
      }

      /**
       * Start part of a multipart
       *
       * @return this request
       * @throws IOException
       */
      protected HttpRequest startPart() throws IOException {
        if (!multipart) {
          multipart = true;
          contentType(CONTENT_TYPE_MULTIPART).openOutput();
          output.write("--" + BOUNDARY + CRLF);
        } else
          output.write(CRLF + "--" + BOUNDARY + CRLF);
        return this;
      }

      /**
       * Write part header
       *
       * @param name
       * @param filename
       * @return this request
       * @throws IOException
       */
      protected HttpRequest writePartHeader(final String name, final String filename)
          throws IOException {
        return writePartHeader(name, filename, null);
      }

      /**
       * Write part header
       *
       * @param name
       * @param filename
       * @param contentType
       * @return this request
       * @throws IOException
       */
      protected HttpRequest writePartHeader(final String name,
          final String filename, final String contentType) throws IOException {
        final StringBuilder partBuffer = new StringBuilder();
        partBuffer.append("form-data; name=\"").append(name);
        if (filename != null)
          partBuffer.append("\"; filename=\"").append(filename);
        partBuffer.append('"');
        partHeader("Content-Disposition", partBuffer.toString());
        if (contentType != null)
          partHeader(HEADER_CONTENT_TYPE, contentType);
        return send(CRLF);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param part
       * @return this request
       */
      public HttpRequest part(final String name, final String part) {
        return part(name, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final String part) throws HttpRequestException {
        return part(name, filename, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param contentType
       *          value of the Content-Type part header
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final String contentType, final String part) throws HttpRequestException {
        try {
          startPart();
          writePartHeader(name, filename, contentType);
          output.write(part);
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return this;
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final Number part)
          throws HttpRequestException {
        return part(name, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final Number part) throws HttpRequestException {
        return part(name, filename, part != null ? part.toString() : null);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final File part)
          throws HttpRequestException {
        return part(name, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final File part) throws HttpRequestException {
        return part(name, filename, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param contentType
       *          value of the Content-Type part header
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final String contentType, final File part) throws HttpRequestException {
        final InputStream stream;
        try {
          stream = new BufferedInputStream(new FileInputStream(part));
          incrementTotalSize(part.length());
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return part(name, filename, contentType, stream);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final InputStream part)
          throws HttpRequestException {
        return part(name, null, null, part);
      }

      /**
       * Write part of a multipart request to the request body
       *
       * @param name
       * @param filename
       * @param contentType
       *          value of the Content-Type part header
       * @param part
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest part(final String name, final String filename,
          final String contentType, final InputStream part)
          throws HttpRequestException {
        try {
          startPart();
          writePartHeader(name, filename, contentType);
          copy(part, output);
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return this;
      }

      /**
       * Write a multipart header to the response body
       *
       * @param name
       * @param value
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest partHeader(final String name, final String value)
          throws HttpRequestException {
        return send(name).send(": ").send(value).send(CRLF);
      }

      /**
       * Write contents of file to request body
       *
       * @param input
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest send(final File input) throws HttpRequestException {
        final InputStream stream;
        try {
          stream = new BufferedInputStream(new FileInputStream(input));
          incrementTotalSize(input.length());
        } catch (FileNotFoundException e) {
          throw new HttpRequestException(e);
        }
        return send(stream);
      }

      /**
       * Write byte array to request body
       *
       * @param input
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest send(final byte[] input) throws HttpRequestException {
        if (input != null)
          incrementTotalSize(input.length);
        return send(new ByteArrayInputStream(input));
      }

      /**
       * Write stream to request body
       * 

       * The given stream will be closed once sending completes
       *
       * @param input
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest send(final InputStream input) throws HttpRequestException {
        try {
          openOutput();
          copy(input, output);
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return this;
      }

      /**
       * Write reader to request body
       * 

       * The given reader will be closed once sending completes
       *
       * @param input
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest send(final Reader input) throws HttpRequestException {
        try {
          openOutput();
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        final Writer writer = new OutputStreamWriter(output,
            output.encoder.charset());
        return new FlushOperation(writer) {

          @Override
          protected HttpRequest run() throws IOException {
            return copy(input, writer);
          }
        }.call();
      }

      /**
       * Write char sequence to request body
       * 

       * The charset configured via {@link #contentType(String)} will be used and
       * UTF-8 will be used if it is unset.
       *
       * @param value
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest send(final CharSequence value) throws HttpRequestException {
        try {
          openOutput();
          output.write(value.toString());
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return this;
      }

      /**
       * Create writer to request output stream
       *
       * @return writer
       * @throws HttpRequestException
       */
      public OutputStreamWriter writer() throws HttpRequestException {
        try {
          openOutput();
          return new OutputStreamWriter(output, output.encoder.charset());
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
      }

      /**
       * Write the values in the map as form data to the request body
       * 

       * The pairs specified will be URL-encoded in UTF-8 and sent with the
       * 'application/x-www-form-urlencoded' content-type
       *
       * @param values
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Map values) throws HttpRequestException {
        return form(values, CHARSET_UTF8);
      }

      /**
       * Write the key and value in the entry as form data to the request body
       * 

       * The pair specified will be URL-encoded in UTF-8 and sent with the
       * 'application/x-www-form-urlencoded' content-type
       *
       * @param entry
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Entry entry) throws HttpRequestException {
        return form(entry, CHARSET_UTF8);
      }

      /**
       * Write the key and value in the entry as form data to the request body
       * 

       * The pair specified will be URL-encoded and sent with the
       * 'application/x-www-form-urlencoded' content-type
       *
       * @param entry
       * @param charset
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Entry entry, final String charset)
          throws HttpRequestException {
        return form(entry.getKey(), entry.getValue(), charset);
      }

      /**
       * Write the name/value pair as form data to the request body
       * 

       * The pair specified will be URL-encoded in UTF-8 and sent with the
       * 'application/x-www-form-urlencoded' content-type
       *
       * @param name
       * @param value
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Object name, final Object value)
          throws HttpRequestException {
        return form(name, value, CHARSET_UTF8);
      }

      /**
       * Write the name/value pair as form data to the request body
       * 

       * The values specified will be URL-encoded and sent with the
       * 'application/x-www-form-urlencoded' content-type
       *
       * @param name
       * @param value
       * @param charset
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Object name, final Object value, String charset)
          throws HttpRequestException {
        final boolean first = !form;
        if (first) {
          contentType(CONTENT_TYPE_FORM, charset);
          form = true;
        }
        charset = getValidCharset(charset);
        try {
          openOutput();
          if (!first)
            output.write('&');
          output.write(URLEncoder.encode(name.toString(), charset));
          output.write('=');
          if (value != null)
            output.write(URLEncoder.encode(value.toString(), charset));
        } catch (IOException e) {
          throw new HttpRequestException(e);
        }
        return this;
      }

      /**
       * Write the values in the map as encoded form data to the request body
       *
       * @param values
       * @param charset
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest form(final Map values, final String charset)
          throws HttpRequestException {
        if (!values.isEmpty())
          for (Entry entry : values.entrySet())
            form(entry, charset);
        return this;
      }

      /**
       * Configure HTTPS connection to trust all certificates
       * 

       * This method does nothing if the current request is not a HTTPS request
       *
       * @return this request
       * @throws HttpRequestException
       */
      public HttpRequest trustAllCerts() throws HttpRequestException {
        final HttpURLConnection connection = getConnection();
        if (connection instanceof HttpsURLConnection)
          ((HttpsURLConnection) connection)
              .setSSLSocketFactory(getTrustedFactory());
        return this;
      }

      /**
       * Configure HTTPS connection to trust all hosts using a custom
       * {@link HostnameVerifier} that always returns true for each
       * host verified
       * 

       * This method does nothing if the current request is not a HTTPS request
       *
       * @return this request
       */
      public HttpRequest trustAllHosts() {
        final HttpURLConnection connection = getConnection();
        if (connection instanceof HttpsURLConnection)
          ((HttpsURLConnection) connection)
              .setHostnameVerifier(getTrustedVerifier());
        return this;
      }

      /**
       * Get the {@link URL} of this request's connection
       *
       * @return request URL
       */
      public URL url() {
        return getConnection().getURL();
      }

      /**
       * Get the HTTP method of this request
       *
       * @return method
       */
      public String method() {
        return getConnection().getRequestMethod();
      }

      /**
       * Configure an HTTP proxy on this connection. Use {{@link #proxyBasic(String, String)} if
       * this proxy requires basic authentication.
       *
       * @param proxyHost
       * @param proxyPort
       * @return this request
       */
      public HttpRequest useProxy(final String proxyHost, final int proxyPort) {
        if (connection != null)
          throw new IllegalStateException("The connection has already been created. This method must be called before reading or writing to the request.");

        this.httpProxyHost = proxyHost;
        this.httpProxyPort = proxyPort;
        return this;
      }

      /**
       * Set whether or not the underlying connection should follow redirects in
       * the response.
       *
       * @param followRedirects - true fo follow redirects, false to not.
       * @return this request
       */
      public HttpRequest followRedirects(final boolean followRedirects) {
        getConnection().setInstanceFollowRedirects(followRedirects);
        return this;
      }

      private void setDefaultTimeOut() {
        getConnection().setConnectTimeout(DEFAULT_CONNECT_TIMEOUT);
        getConnection().setReadTimeout(DEFAULT_READ_TIMEOUT);
      }

      public HttpRequest defaultTimeOut() {
        this.defaultTimeOutFlag = true;
        return this;
      }
      /**
       *
       * HttpResponse collects the http response info and make the responsibility clearly(HttpRequest for request,HttpResponse for response)
       *
       */
      public class HttpResponse{

        /**
         * Get the status code of the response
         *
         * @return the response code
         * @throws HttpRequestException
         */
        public int code() throws HttpRequestException {
          try {
            closeOutput();
            return getConnection().getResponseCode();
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
        }

        /**
         * Close output stream
         *
         * @return this response
         * @throws HttpRequestException
         * @throws IOException
         */
        protected HttpResponse closeOutput() throws IOException {
          progress(null);
          if (output == null)
            return this;
          if (multipart)
            output.write(CRLF + "--" + BOUNDARY + "--" + CRLF);
          if (ignoreCloseExceptions)
            try {
              output.close();
            } catch (IOException ignored) {
              // Ignored
            }
          else
            output.close();
          output = null;
          return this;
        }

        /**
         * Set the value of the given {@link AtomicInteger} to the status code of the
         * response
         *
         * @param output
         * @return this response
         * @throws HttpRequestException
         */
        public HttpResponse code(final AtomicInteger output)
            throws HttpRequestException {
          output.set(code());
          return this;
        }

        /**
         * Call {@link #closeOutput()} and re-throw a caught {@link IOException}s as
         * an {@link HttpRequestException}
         *
         * @return this response
         * @throws HttpRequestException
         */
        protected HttpResponse closeOutputQuietly() throws HttpRequestException {
          try {
            return closeOutput();
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
        }

        /**
         * Is the response code a 200 OK?
         *
         * @return true if 200, false otherwise
         * @throws HttpRequestException
         */
        public boolean ok() throws HttpRequestException {
          return HTTP_OK == code();
        }


        /**
         * Is the response code a 201 Created?
         *
         * @return true if 201, false otherwise
         * @throws HttpRequestException
         */
        public boolean created() throws HttpRequestException {
          return HTTP_CREATED == code();
        }

        /**
         * Is the response code a 204 No Content?
         *
         * @return true if 204, false otherwise
         * @throws HttpRequestException
         */
        public boolean noContent() throws HttpRequestException {
          return HTTP_NO_CONTENT == code();
        }

        /**
         * Is the response code a 500 Internal Server Error?
         *
         * @return true if 500, false otherwise
         * @throws HttpRequestException
         */
        public boolean serverError() throws HttpRequestException {
          return HTTP_INTERNAL_ERROR == code();
        }

        /**
         * Is the response code a 400 Bad Request?
         *
         * @return true if 400, false otherwise
         * @throws HttpRequestException
         */
        public boolean badRequest() throws HttpRequestException {
          return HTTP_BAD_REQUEST == code();
        }

        /**
         * Is the response code a 404 Not Found?
         *
         * @return true if 404, false otherwise
         * @throws HttpRequestException
         */
        public boolean notFound() throws HttpRequestException {
          return HTTP_NOT_FOUND == code();
        }

        /**
         * Is the response code a 304 Not Modified?
         *
         * @return true if 304, false otherwise
         * @throws HttpRequestException
         */
        public boolean notModified() throws HttpRequestException {
          return HTTP_NOT_MODIFIED == code();
        }

        /**
         * Get status message of the response
         *
         * @return message
         * @throws HttpRequestException
         */
        public String message() throws HttpRequestException {
          try {
            closeOutput();
            return getConnection().getResponseMessage();
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
        }


        /**
         * Get response as {@link String} in given character set
         * 

         * This will fall back to using the UTF-8 character set if the given charset
         * is null
         *
         * @param charset
         * @return string
         * @throws HttpRequestException
         */
        public String body(final String charset) throws HttpRequestException {
          final ByteArrayOutputStream output = byteStream();
          try {
            copy(buffer(), output);
            return output.toString(getValidCharset(charset));
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
        }

        /**
         * Get response as {@link String} using character set returned from
         * {@link #charset()}
         *
         * @return string
         * @throws HttpRequestException
         */
        public String body() throws HttpRequestException {
          return body(charset());
        }

        /**
         * Get the response body as a {@link String} and set it as the value of the
         * given reference.
         *
         * @param output
         * @return this response
         * @throws HttpRequestException
         */
        public HttpResponse body(final AtomicReference output) throws HttpRequestException {
          output.set(body());
          return this;
        }

        /**
         * Get the response body as a {@link String} and set it as the value of the
         * given reference.
         *
         * @param output
         * @param charset
         * @return this response
         * @throws HttpRequestException
         */
        public HttpResponse body(final AtomicReference output, final String charset) throws HttpRequestException {
          output.set(body(charset));
          return this;
        }


        /**
         * Is the response body empty?
         *
         * @return true if the Content-Length response header is 0, false otherwise
         * @throws HttpRequestException
         */
        public boolean isBodyEmpty() throws HttpRequestException {
          return contentLength() == 0;
        }

        /**
         * Get response as byte array
         *
         * @return byte array
         * @throws HttpRequestException
         */
        public byte[] bytes() throws HttpRequestException {
          final ByteArrayOutputStream output = byteStream();
          try {
            copy(buffer(), output);
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
          return output.toByteArray();
        }

        /**
         * Get response in a buffered stream
         *
         * @see #bufferSize(int)
         * @return stream
         * @throws HttpRequestException
         */
        public BufferedInputStream buffer() throws HttpRequestException {
          return new BufferedInputStream(stream(), bufferSize);
        }
        /**
         * Get a response header
         *
         * @param name
         * @return response header
         * @throws HttpRequestException
         */
        public String header(final String name) throws HttpRequestException {
          closeOutputQuietly();
          return getConnection().getHeaderField(name);
        }

        /**
         * Get all the response headers
         *
         * @return map of response header names to their value(s)
         * @throws HttpRequestException
         */
        public Map> headers() throws HttpRequestException {
          closeOutputQuietly();
          return getConnection().getHeaderFields();
        }

        /**
         * Get a date header from the response falling back to returning -1 if the
         * header is missing or parsing fails
         *
         * @param name
         * @return date, -1 on failures
         * @throws HttpRequestException
         */
        public long dateHeader(final String name) throws HttpRequestException {
          return dateHeader(name, -1L);
        }

        /**
         * Get a date header from the response falling back to returning the given
         * default value if the header is missing or parsing fails
         *
         * @param name
         * @param defaultValue
         * @return date, default value on failures
         * @throws HttpRequestException
         */
        public long dateHeader(final String name, final long defaultValue)
            throws HttpRequestException {
          closeOutputQuietly();
          return getConnection().getHeaderFieldDate(name, defaultValue);
        }


        /**
         * Get the 'Content-Encoding' header from the response
         *
         * @return this request
         */
        public String contentEncoding() {
          return header(HEADER_CONTENT_ENCODING);
        }

        /**
         * Get the 'Server' header from the response
         *
         * @return server
         */
        public String server() {
          return header(HEADER_SERVER);
        }

        /**
         * Get the 'Date' header from the response
         *
         * @return date value, -1 on failures
         */
        public long date() {
          return dateHeader(HEADER_DATE);
        }

        /**
         * Get the 'Cache-Control' header from the response
         *
         * @return cache control
         */
        public String cacheControl() {
          return header(HEADER_CACHE_CONTROL);
        }

        /**
         * Get the 'ETag' header from the response
         *
         * @return entity tag
         */
        public String eTag() {
          return header(HEADER_ETAG);
        }

        /**
         * Get the 'Expires' header from the response
         *
         * @return expires value, -1 on failures
         */
        public long expires() {
          return dateHeader(HEADER_EXPIRES);
        }

        /**
         * Get the 'Last-Modified' header from the response
         *
         * @return last modified value, -1 on failures
         */
        public long lastModified() {
          return dateHeader(HEADER_LAST_MODIFIED);
        }

        /**
         * Get the 'Location' header from the response
         *
         * @return location
         */
        public String location() {
          return header(HEADER_LOCATION);
        }

        /**
         * Get parameter with given name from header value in response
         *
         * @param headerName
         * @param paramName
         * @return parameter value or null if missing
         */
        public String parameter(final String headerName, final String paramName) {
          return getParam(header(headerName), paramName);
        }

        /**
         * Get all parameters from header value in response
         * 

         * This will be all key=value pairs after the first ';' that are separated by
         * a ';'
         *
         * @param headerName
         * @return non-null but possibly empty map of parameter headers
         */
        public Map parameters(final String headerName) {
          return getParams(header(headerName));
        }

        /**
         * Get 'charset' parameter from 'Content-Type' response header
         *
         * @return charset or null if none
         */
        public String charset() {
          return parameter(HEADER_CONTENT_TYPE, PARAM_CHARSET);
        }

        /**
         * Get all values of the given header from the response
         *
         * @param name
         * @return non-null but possibly empty array of {@link String} header values
         */
        public String[] headers(final String name) {
          final Map> headers = headers();
          if (headers == null || headers.isEmpty())
            return EMPTY_STRINGS;

          final List values = headers.get(name);
          if (values != null && !values.isEmpty())
            return values.toArray(new String[values.size()]);
          else
            return EMPTY_STRINGS;
        }


        /**
         * Create byte array output stream
         *
         * @return stream
         */
        protected ByteArrayOutputStream byteStream() {
          final int size = contentLength();
          if (size > 0)
            return new ByteArrayOutputStream(size);
          else
            return new ByteArrayOutputStream();
        }

        /**
         * Get the 'Content-Length' header from the response
         *
         * @return response header value
         */
        public int contentLength() {
          return intHeader(HEADER_CONTENT_LENGTH);
        }

        /**
         * Get an integer header from the response falling back to returning -1 if the
         * header is missing or parsing fails
         *
         * @param name
         * @return header value as an integer, -1 when missing or parsing fails
         * @throws HttpRequestException
         */
        public int intHeader(final String name) throws HttpRequestException {
          return intHeader(name, -1);
        }

        /**
         * Get an integer header value from the response falling back to the given
         * default value if the header is missing or if parsing fails
         *
         * @param name
         * @param defaultValue
         * @return header value as an integer, default value when missing or parsing
         *         fails
         * @throws HttpRequestException
         */
        public int intHeader(final String name, final int defaultValue)
            throws HttpRequestException {
          closeOutputQuietly();
          return getConnection().getHeaderFieldInt(name, defaultValue);
        }

        /**
         * Get stream to response body
         *
         * @return stream
         * @throws HttpRequestException
         */
        public InputStream stream() throws HttpRequestException {
          if (defaultTimeOutFlag) {
            setDefaultTimeOut();
          }
          InputStream stream;
          if (code() < HTTP_BAD_REQUEST)
            try {
              stream = getConnection().getInputStream();
            } catch (IOException e) {
              throw new HttpRequestException(e);
            }
          else {
            stream = getConnection().getErrorStream();
            if (stream == null)
              try {
                stream = getConnection().getInputStream();
              } catch (IOException e) {
                if (contentLength() > 0)
                  throw new HttpRequestException(e);
                else
                  stream = new ByteArrayInputStream(new byte[0]);
              }
          }

          if (!uncompress || !ENCODING_GZIP.equals(contentEncoding()))
            return stream;
          else
            try {
              return new GZIPInputStream(stream);
            } catch (IOException e) {
              throw new HttpRequestException(e);
            }
        }


        /**
         * Get reader to response body using given character set.
         * 

         * This will fall back to using the UTF-8 character set if the given charset
         * is null
         *
         * @param charset
         * @return reader
         * @throws HttpRequestException
         */
        public InputStreamReader reader(final String charset)
            throws HttpRequestException {
          try {
            return new InputStreamReader(stream(), getValidCharset(charset));
          } catch (UnsupportedEncodingException e) {
            throw new HttpRequestException(e);
          }
        }

        /**
         * Get reader to response body using the character set returned from
         * {@link #charset()}
         *
         * @return reader
         * @throws HttpRequestException
         */
        public InputStreamReader reader() throws HttpRequestException {
          return reader(charset());
        }


        /**
         * Get buffered reader to response body using the given character set r and
         * the configured buffer size
         *
         *
         * @see #bufferSize(int)
         * @param charset
         * @return reader
         * @throws HttpRequestException
         */
        public BufferedReader bufferedReader(final String charset)
            throws HttpRequestException {
          return new BufferedReader(reader(charset), bufferSize);
        }

        /**
         * Get buffered reader to response body using the character set returned from
         * {@link #charset()} and the configured buffer size
         *
         * @see #bufferSize(int)
         * @return reader
         * @throws HttpRequestException
         */
        public BufferedReader bufferedReader() throws HttpRequestException {
          return bufferedReader(charset());
        }

        /**
         * Stream response body to file
         *
         * @param file
         * @return this request
         * @throws HttpRequestException
         */
        public HttpResponse receive(final File file) throws HttpRequestException {
          final OutputStream output;
          try {
            output = new BufferedOutputStream(new FileOutputStream(file), bufferSize);
          } catch (FileNotFoundException e) {
            throw new HttpRequestException(e);
          }
          return new CloseOperation(output, ignoreCloseExceptions) {

            @Override
            protected HttpResponse run() throws HttpRequestException, IOException {
              return receive(output);
            }
          }.call();
        }

        /**
         * Stream response to given output stream
         *
         * @param output
         * @return this request
         * @throws HttpRequestException
         */
        public HttpResponse receive(final OutputStream output)
            throws HttpRequestException {
          try {
            return copy(buffer(), output);
          } catch (IOException e) {
            throw new HttpRequestException(e);
          }
        }

        /**
         * Stream response to given print stream
         *
         * @param output
         * @return this request
         * @throws HttpRequestException
         */
        public HttpResponse receive(final PrintStream output)
            throws HttpRequestException {
          return receive((OutputStream) output);
        }

        /**
         * Receive response into the given appendable
         *
         * @param appendable
         * @return this request
         * @throws HttpRequestException
         */
        public HttpResponse receive(final Appendable appendable)
            throws HttpRequestException {
          final BufferedReader reader = bufferedReader();
          return new CloseOperation(reader, ignoreCloseExceptions) {

            @Override
            public HttpResponse run() throws IOException {
              final CharBuffer buffer = CharBuffer.allocate(bufferSize);
              int read;
              while ((read = reader.read(buffer)) != -1) {
                buffer.rewind();
                appendable.append(buffer, 0, read);
                buffer.rewind();
              }
              return HttpRequest.this.httpResponse;
            }
          }.call();
        }
      }
      /**
       * this method is used to execute a http request and get a HttpResponse
       * @return
       */
      public HttpResponse executeHttpRequest(){
        if (httpResponse ==null) {
          httpResponse = new HttpResponse();
        }
        return httpResponse;
      }

    }
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码学习,个人简介有邮箱)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动
                        李蕾1229

                        
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 我的烦恼
                        余建梅

                        
    我的烦恼。女儿问我：“你给学生布置什么作文题目？”“《我的烦恼》。”“他们都这么大了，你觉得他们还有烦恼吗？”“有啊！每个人都会有自己烦恼。”“我不相信，大人是没有烦恼的，如果说一定有的话，你的烦恼和我写作业有关，而且是小烦恼。不像我，天天被你说，有这样的妈妈，烦恼是没完没了。”女儿愤愤不平。每个人都会有自己的烦恼，处在上有老下有小的年纪，烦恼多的数不完。想干好工作带好孩子，想孝顺父母又想经营好自
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 活给自己看，笑容才灿烂
                        听着了么

                        
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
    
                    
    • 
                    
  • 网易严选官方旗舰店，优质商品，卓越服务
                        高省_飞智666600

                        
    网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 相信相信的力量
                        孙丽_cdb3

                        
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 我的黑历史
                        袖手围观有来有去

                        
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 《中华小厨师》单行VS爱藏：姜是老的辣，书是新的好
                        cicoky

                        
    《汉书·郦食其传》有曰：“王者以民为天，而民以食为天。”自古以来，吃饱饭是每一个人的基本要求，而吃好饭却是每一个人的最终追求。于是，厨师这一职业孕育而生，其渊源之久，甚至可追溯到4000年前的奴隶时代。职业本身无贵贱，但职业能力却有高低之分。所以一家餐馆生意好不好，厨师的水平决定一切，而站在所有厨师顶端的就被称之为“特级厨师”。今天要说的就是一个关于“特级厨师刘昴星”的故事。连载历程1995年第4
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • 读《人世间》有感
                        一0一

                        
    这个寒假，就如同朋友圈中的一段话：一闭眼，一睁眼假期还有5天，在一闭眼一睁眼假期还有12天；再一闭眼一睁眼假期还有20天；不敢睡，不敢睡啊……受疫情影响，这个假期变得漫长又煎熬，我也无时无刻不关注着疫情的变化。当然这样的一个假期，我还真得要感谢周翔，因为他有个爱看书的习惯，所以家里有不少他看过的书，可以让我随意挑选，因此也让我的假期不至于那么无所事事。这次我选了一本梁晓声的《人世间》，作为一名语文
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 万物难度不度己
                        边度512

                        
    你好，陌生人！你是否有过迷茫，在别人的面前自己却不曾展示！你是否自己承担着所有的痛苦，却又笑对人生！你是否在很多时候想找人诉说，翻开手机却发现，手机里面空无一人！你是否有很多事情想做，最后却因你自己拖延，最后发现自己什么都做不了！对没有错，我的名字就叫你是否！不要怀疑！不要悲伤！我们的生活可是还有很到要继续的呢！还有很多那个人，很多地方我们都没有去过！所以我们已经没有退路了！那就继续向前吧！加油！
    
                    
    • 
                    
  • 少了生活气息
                        我爱大草莓

                        
    最近啊，总觉得自己日更的内容缺了点什么。我仔细地想，大概是少了些生活气息。这两三个月减少了许多与别人相处的时间，独自生活，偶尔只是出去买菜，总觉得生活好像变空了许多。买菜的时候会跟档口的阿姨聊一两句话，让自己感觉在真实地生活着。幸好我也不是一宅到底，偶尔周末也会约着跟好朋友见面，面对面交流跟隔着屏幕交流，效果还是不一样的，至少有更为真实的生活感。写作不仅需要有阅读量，有文笔，生活阅历也是非常重要的
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 398顺境，逆境
                        戴骁勇

                        
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
    
                    
    • 
                    
  • python是什么意思中文-在python中%是什么意思
                        编程大乐趣

                        
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • 无题，感慨
                        竹间书编辑

                        
    玉生烟，雪落天，枯叶随雪葬行边，何有芳名，流落人世间。雪中行，路中停，风送鹅雪风无情，且将留此，风波却未平
    
                    
    • 
                                
  • Spring中@Value注解，需要注意的地方
                                    无量
springbean@Valuexml
                                    
    Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 
 
 
1、在applicationContext.xml文件(或引用文件中)中配置properties文件 
 
<bean id="appProperty"
    class="org.springframework.beans.fac
    
                                
    • 
                                
  • mongoDB 分片
                                    开窍的石头
mongodb
                                    
        mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。 
    第一步启动两台以上的mongo服务 
&nb
    
                                
    • 
                                
  • OVER(PARTITION BY)函数用法
                                    0624chenhong
oracle
                                    
    这篇写得很好，引自 
http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html 
 
 
OVER(PARTITION BY)函数用法 
 
 2010年10月26日 
 
OVER(PARTITION BY)函数介绍 
 
开窗函数        &nb
    
                                
    • 
                                
  • Android开发中，ADB server didn't ACK 解决方法
                                    一炮送你回车库
Android开发
                                    
    首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。 
  
一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 
参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 
简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 
&nb
    
                                
    • 
                                
  • canvas中的像素绘制问题
                                    换个号韩国红果果
JavaScriptcanvas
                                    
    pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 
2.如果绘制点为一个像素的
    
                                
    • 
                                
  • 编码乱码问题
                                    灵静志远
javajvmjsp编码
                                    
    1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 
3、getBytes()、getByte
    
                                
    • 
                                
  • java 求几个月后的日期
                                    darkranger
calendargetinstance
                                    
    Date plandate = planDate.toDate();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(plandate);
// 取得三个月后时间
cal.add(Calendar.M
    
                                
    • 
                                
  • 数据库设计的三大范式（通俗易懂）
                                    aijuans
数据库复习
                                    
    关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 
目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
    
                                
    • 
                                
  • 想学工作流怎么入手
                                    atongyeye
jbpm
                                    
    工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 
 
 
系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 
 
本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 
 
1  首先要
    
                                
    • 
                                
  • Context和SQLiteOpenHelper创建数据库
                                    百合不是茶
androidContext创建数据库
                                    
           一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 
  
  
一:SQLiteOpenHelper创建数据库: 
  
1,SQLi
    
                                
    • 
                                
  • 浅谈group by和distinct
                                    bijian1013
oracle数据库group bydistinct
                                    
            group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。 
        譬如：统计每id数并且只显示数大于3 
select id ,count(id) from ta
    
                                
    • 
                                
  • vi opertion
                                    征客丶
macoprationvi
                                    
    进入 command mode （命令行模式） 
按 esc 键 
再按 shift + 冒号 
 
注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 
 
一、文件操作 
1.1、强制退出不保存 
$ q! 
1.2、保存 
$ w 
1.3、保存并退出 
$ wq 
1.4、刷新或重新加载已打开的文件 
$ e 
 
二、光标移动 
2.1、跳到指定行 
数字
    
                                
    • 
                                
  • 【Spark十四】深入Spark RDD第三部分RDD基本API
                                    bit1129
spark
                                    
      
对于K/V类型的RDD,如下操作是什么含义？ 
  
val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5))
rdd.reduceByKey(_+_).collect 
 reduceByKey在这里的操作，是把
    
                                
    • 
                                
  • java类加载机制
                                    BlueSkator
java虚拟机
                                    
    java类加载机制 
1.java类加载器的树状结构 
引导类加载器 
^ 
| 
扩展类加载器 
^ 
| 
系统类加载器 
java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 
虚拟机区分一个Cla
    
                                
    • 
                                
  • 动态添加文本框
                                    BreakingBad
文本框
                                    
      <script>     var num=1; function AddInput() {      var str="";     str+="<input 
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-单例模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



public class Singleton {
}

/*
 * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题
 */
class LazySingleton
    
                                
    • 
                                
  • iOS应用打包发布常见问题
                                    chenhbc
iosiOS发布iOS上传iOS打包
                                    
    这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 
  
1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
    
                                
    • 
                                
  • 工作流复杂拓扑结构处理新思路
                                    comsci
设计模式工作算法企业应用OO
                                    
     我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
    
                                
    • 
                                
  • oracle 11g新特性Flashback data archive
                                    daizj
oracle
                                    
    1. 什么是flashback data archive 
 
Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。 
    
                                
    • 
                                
  • 多叉树:2-3-4树
                                    dieslrae
树
                                    
        平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 
    1、有一个数据项的节点总是有2个子节点(称为2-节点) 
    2、有两个数据项的节点总是有3个子节点(称为3-节
    
                                
    • 
                                
  • C语言学习七动态分配 malloc的使用
                                    dcj3sjt126com
clanguagemalloc
                                    
    /*
	2013年3月15日15:16:24
	malloc 就memory(内存) allocate(分配)的缩写
	本程序没有实际含义，只是理解使用	
 */
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int i = 5;	//分配了4个字节 静态分配
	int * p 
    
                                
    • 
                                
  • Objective-C编码规范[译]
                                    dcj3sjt126com
代码规范
                                    
         
 
  
  原文链接 : The official raywenderlich.com Objective-C style guide  
  原文作者 : raywenderlich.com Team  
  译文出自 : raywenderlich.com Objective-C编码规范  
  译者 : Sam Lau  
  
    
                                
    • 
                                
  • 0.性能优化-目录
                                    frank1234
性能优化
                                    
    从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 
主要内容包括： 
一、性能测试指标 
吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 
http://frank1234.iteye.com/blog/2180305 
 
二、性能测试策略 
生产环境相同 基准测试 预热等 
htt
    
                                
    • 
                                
  • Java父类取得子类传递的泛型参数Class类型
                                    happyqing
java泛型父类子类Class
                                    
      
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

abstract class BaseDao<T> {
	public void getType() {
		//Class<E> clazz =
    
                                
    • 
                                
  • 跟我学SpringMVC目录汇总贴、PDF下载、源码下载
                                    jinnianshilongnian
springMVC
                                    
      
----广告-------------------------------------------------------------- 
网站核心商详页开发 
掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 
掌握数据库技术，表设计和索引优化，分库分表/读写分离； 
了解缓存技术，熟练使用如Redis/Memcached等主流技术； 
了解Ngin
    
                                
    • 
                                
  • the HTTP rewrite module requires the PCRE library
                                    流浪鱼
rewrite
                                    
    ./configure: error: the HTTP rewrite module requires the PCRE library. 
模块依赖性Nginx需要依赖下面3个包 
1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 
2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 
3. s
    
                                
    • 
                                
  • 第12章 Ajax（中）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Optimize query with Query Stripping in Web Intelligence
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence 
and a very straightfoward video 
http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
    
                                
    • 
                                
  • Java开发者写SQL时常犯的10个错误
                                    tomcat_oracle
javasql
                                    
    1、不用PreparedStatements   　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：   　　他们对PreparedStatements不了解   　　他们认为使用PreparedStatements太慢了   　　他们认为写Prepar
    
                                
    • 
                                
  • 世纪互联与结盟有感
                                    阿尔萨斯

                                    
     10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 
 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 
 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
    
                                
    •