WebbUtils.java

  1. package com.goebl.david;

  3. import org.json.JSONArray;
  4. import org.json.JSONException;
  5. import org.json.JSONObject;

  7. import java.io.ByteArrayOutputStream;
  8. import java.io.File;
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.OutputStream;
  12. import java.io.UnsupportedEncodingException;
  13. import java.net.HttpURLConnection;
  14. import java.net.URLEncoder;
  15. import java.text.DateFormat;
  16. import java.text.SimpleDateFormat;
  17. import java.util.Calendar;
  18. import java.util.Date;
  19. import java.util.Locale;
  20. import java.util.Map;
  21. import java.util.TimeZone;
  22. import java.util.zip.GZIPInputStream;
  23. import java.util.zip.GZIPOutputStream;
  24. import java.util.zip.Inflater;
  25. import java.util.zip.InflaterInputStream;

  27. /**
  28.  * Static utility method and tools for HTTP traffic parsing and encoding.
  29.  *
  30.  * @author hgoebl
  31.  */
  32. public class WebbUtils {

  34.     protected WebbUtils() {}

  36.     /**
  37.      * Convert a Map to a query string.
  38.      * @param values the map with the values
  39.      *               <code>null</code> will be encoded as empty string, all other objects are converted to
  40.      *               String by calling its <code>toString()</code> method.
  41.      * @return e.g. "key1=value&amp;key2=&amp;email=max%40example.com"
  42.      */
  43.     public static String queryString(Map<String, Object> values) {
  44.         StringBuilder sbuf = new StringBuilder();
  45.         String separator = "";

  47.         for (Map.Entry<String, Object> entry : values.entrySet()) {
  48.             Object entryValue = entry.getValue();
  49.             if (entryValue instanceof Object[]) {
  50.                 for (Object value : (Object[]) entryValue) {
  51.                     appendParam(sbuf, separator, entry.getKey(), value);
  52.                     separator = "&";
  53.                 }
  54.             } else if (entryValue instanceof Iterable) {
  55.                 for (Object multiValue : (Iterable) entryValue) {
  56.                     appendParam(sbuf, separator, entry.getKey(), multiValue);
  57.                     separator = "&";
  58.                 }
  59.             } else {
  60.                 appendParam(sbuf, separator, entry.getKey(), entryValue);
  61.                 separator = "&";
  62.             }
  63.         }

  65.         return sbuf.toString();
  66.     }

  68.     private static void appendParam(StringBuilder sbuf, String separator, String entryKey, Object value) {
  69.         String sValue = value == null ? "" : String.valueOf(value);
  70.         sbuf.append(separator);
  71.         sbuf.append(urlEncode(entryKey));
  72.         sbuf.append('=');
  73.         sbuf.append(urlEncode(sValue));
  74.     }

  76.     /**
  77.      * Convert a byte array to a JSONObject.
  78.      * @param bytes a UTF-8 encoded string representing a JSON object.
  79.      * @return the parsed object
  80.      * @throws WebbException in case of error (usually a parsing error due to invalid JSON)
  81.      */
  82.     public static JSONObject toJsonObject(byte[] bytes) {
  83.         String json;
  84.         try {
  85.             json = new String(bytes, Const.UTF8);
  86.             return new JSONObject(json);
  87.         } catch (UnsupportedEncodingException e) {
  88.             throw new WebbException(e);
  89.         } catch (JSONException e) {
  90.             throw new WebbException("payload is not a valid JSON object", e);
  91.         }
  92.     }

  94.     /**
  95.      * Convert a byte array to a JSONArray.
  96.      * @param bytes a UTF-8 encoded string representing a JSON array.
  97.      * @return the parsed JSON array
  98.      * @throws WebbException in case of error (usually a parsing error due to invalid JSON)
  99.      */
  100.     public static JSONArray toJsonArray(byte[] bytes) {
  101.         String json;
  102.         try {
  103.             json = new String(bytes, Const.UTF8);
  104.             return new JSONArray(json);
  105.         } catch (UnsupportedEncodingException e) {
  106.             throw new WebbException(e);
  107.         } catch (JSONException e) {
  108.             throw new WebbException("payload is not a valid JSON array", e);
  109.         }
  110.     }

  112.     /**
  113.      * Read an <code>InputStream</code> into <code>byte[]</code> until EOF.
  114.      * <br>
  115.      * Does not close the InputStream!
  116.      *
  117.      * @param is the stream to read the bytes from
  118.      * @return all read bytes as an array
  119.      * @throws IOException when read or write operation fails
  120.      */
  121.     public static byte[] readBytes(InputStream is) throws IOException {
  122.         if (is == null) {
  123.             return null;
  124.         }
  125.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  126.         copyStream(is, baos);
  127.         return baos.toByteArray();
  128.     }

  130.     /**
  131.      * Copy complete content of <code>InputStream</code> to <code>OutputStream</code> until EOF.
  132.      * <br>
  133.      * Does not close the InputStream nor OutputStream!
  134.      *
  135.      * @param input the stream to read the bytes from
  136.      * @param output the stream to write the bytes to
  137.      * @throws IOException when read or write operation fails
  138.      */
  139.     public static void copyStream(InputStream input, OutputStream output) throws IOException {
  140.         byte[] buffer = new byte[1024];
  141.         int count;
  142.         while ((count = input.read(buffer)) != -1) {
  143.             output.write(buffer, 0, count);
  144.         }
  145.     }

  147.     /**
  148.      * Creates a new instance of a <code>DateFormat</code> for RFC1123 compliant dates.
  149.      * <br>
  150.      * Should be stored for later use but be aware that this DateFormat is not Thread-safe!
  151.      * <br>
  152.      * If you have to deal with dates in this format with JavaScript, it's easy, because the JavaScript
  153.      * Date object has a constructor for strings formatted this way.
  154.      * @return a new instance
  155.      */
  156.     public static DateFormat getRfc1123DateFormat() {
  157.         DateFormat format = new SimpleDateFormat(
  158.                 "EEE, dd MMM yyyy HH:mm:ss z", Locale.ENGLISH);
  159.         format.setLenient(false);
  160.         format.setTimeZone(TimeZone.getTimeZone("UTC"));
  161.         return format;
  162.     }

  164.     static String urlEncode(String value) {
  165.         try {
  166.             return URLEncoder.encode(value, "UTF-8");
  167.         } catch (UnsupportedEncodingException e) {
  168.             return value;
  169.         }
  170.     }

  172.     static void addRequestProperties(HttpURLConnection connection, Map<String, Object> map) {
  173.         if (map == null || map.isEmpty()) {
  174.             return;
  175.         }
  176.         for (Map.Entry<String, Object> entry : map.entrySet()) {
  177.             addRequestProperty(connection, entry.getKey(), entry.getValue());
  178.         }
  179.     }

  181.     static void addRequestProperty(HttpURLConnection connection, String name, Object value) {
  182.         if (name == null || name.length() == 0 || value == null) {
  183.             throw new IllegalArgumentException("name and value must not be empty");
  184.         }

  186.         String valueAsString;
  187.         if (value instanceof Date) {
  188.             valueAsString = getRfc1123DateFormat().format((Date) value);
  189.         } else if (value instanceof Calendar) {
  190.             valueAsString = getRfc1123DateFormat().format(((Calendar) value).getTime());
  191.         } else {
  192.             valueAsString = value.toString();
  193.         }

  195.         connection.addRequestProperty(name, valueAsString);
  196.     }

  198.     static void ensureRequestProperty(HttpURLConnection connection, String name, Object value) {
  199.         if (!connection.getRequestProperties().containsKey(name)) {
  200.             addRequestProperty(connection, name, value);
  201.         }
  202.     }

  204.     static byte[] getPayloadAsBytesAndSetContentType(
  205.             HttpURLConnection connection,
  206.             Request request,
  207.             boolean compress,
  208.             int jsonIndentFactor) throws JSONException, UnsupportedEncodingException {

  210.         byte[] requestBody = null;
  211.         String bodyStr = null;

  213.         if (request.params != null) {
  214.             WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_FORM);
  215.             bodyStr = WebbUtils.queryString(request.params);
  216.         } else if (request.payload == null) {
  217.             return null;
  218.         } else if (request.payload instanceof JSONObject) {
  219.             WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_JSON);
  220.             bodyStr = jsonIndentFactor >= 0
  221.                     ? ((JSONObject) request.payload).toString(jsonIndentFactor)
  222.                     : request.payload.toString();
  223.         } else if (request.payload instanceof JSONArray) {
  224.             WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_JSON);
  225.             bodyStr = jsonIndentFactor >= 0
  226.                     ? ((JSONArray) request.payload).toString(jsonIndentFactor)
  227.                     : request.payload.toString();
  228.         } else if (request.payload instanceof byte[]) {
  229.             WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_BINARY);
  230.             requestBody = (byte[]) request.payload;
  231.         } else {
  232.             WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.TEXT_PLAIN);
  233.             bodyStr = request.payload.toString();
  234.         }
  235.         if (bodyStr != null) {
  236.             requestBody = bodyStr.getBytes(Const.UTF8);
  237.         }

  239.         if (requestBody == null) {
  240.             throw new IllegalStateException();
  241.         }

  243.         // only compress if the new body is smaller than uncompressed body
  244.         if (compress && requestBody.length > Const.MIN_COMPRESSED_ADVANTAGE) {
  245.             byte[] compressedBody = gzip(requestBody);
  246.             if (requestBody.length - compressedBody.length > Const.MIN_COMPRESSED_ADVANTAGE) {
  247.                 requestBody = compressedBody;
  248.                 connection.setRequestProperty(Const.HDR_CONTENT_ENCODING, "gzip");
  249.             }
  250.         }

  252.         connection.setFixedLengthStreamingMode(requestBody.length);

  254.         return requestBody;
  255.     }

  257.     static void setContentTypeAndLengthForStreaming(
  258.             HttpURLConnection connection,
  259.             Request request,
  260.             boolean compress) {

  262.         long length;

  264.         if (request.payload instanceof File) {
  265.             length = compress ? -1L : ((File) request.payload).length();
  266.         } else if (request.payload instanceof InputStream) {
  267.             length = -1L;
  268.         } else {
  269.             throw new IllegalStateException();
  270.         }

  272.         if (length > Integer.MAX_VALUE) {
  273.             length = -1L; // use chunked streaming mode
  274.         }

  276.         WebbUtils.ensureRequestProperty(connection, Const.HDR_CONTENT_TYPE, Const.APP_BINARY);
  277.         if (length < 0) {
  278.             connection.setChunkedStreamingMode(-1); // use default chunk size
  279.             if (compress) {
  280.                 connection.setRequestProperty(Const.HDR_CONTENT_ENCODING, "gzip");
  281.             }
  282.         } else {
  283.             connection.setFixedLengthStreamingMode((int) length);
  284.         }
  285.     }

  287.     static byte[] gzip(byte[] input) {
  288.         GZIPOutputStream gzipOS = null;
  289.         try {
  290.             ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
  291.             gzipOS = new GZIPOutputStream(byteArrayOS);
  292.             gzipOS.write(input);
  293.             gzipOS.flush();
  294.             gzipOS.close();
  295.             gzipOS = null;
  296.             return byteArrayOS.toByteArray();
  297.         } catch (Exception e) {
  298.             throw new WebbException(e);
  299.         } finally {
  300.             if (gzipOS != null) {
  301.                 try { gzipOS.close(); } catch (Exception ignored) {}
  302.             }
  303.         }
  304.     }

  306.     static InputStream wrapStream(String contentEncoding, InputStream inputStream) throws IOException {
  307.         if (contentEncoding == null || "identity".equalsIgnoreCase(contentEncoding)) {
  308.             return inputStream;
  309.         }
  310.         if ("gzip".equalsIgnoreCase(contentEncoding)) {
  311.             return new GZIPInputStream(inputStream);
  312.         }
  313.         if ("deflate".equalsIgnoreCase(contentEncoding)) {
  314.             return new InflaterInputStream(inputStream, new Inflater(false), 512);
  315.         }
  316.         throw new WebbException("unsupported content-encoding: " + contentEncoding);
  317.     }

  319.     static <T> void parseResponseBody(Class<T> clazz, Response<T> response, InputStream responseBodyStream)
  320.             throws UnsupportedEncodingException, IOException {

  322.         if (responseBodyStream == null || clazz == Void.class) {
  323.             return;
  324.         } else if (clazz == InputStream.class) {
  325.             response.setBody(responseBodyStream);
  326.             return;
  327.         }

  329.         byte[] responseBody = WebbUtils.readBytes(responseBodyStream);
  330.         // we are ignoring headers describing the content type of the response, instead
  331.         // try to force the content based on the type the client is expecting it (clazz)
  332.         if (clazz == String.class) {
  333.             response.setBody(new String(responseBody, Const.UTF8));
  334.         } else if (clazz == Const.BYTE_ARRAY_CLASS) {
  335.             response.setBody(responseBody);
  336.         } else if (clazz == JSONObject.class) {
  337.             response.setBody(WebbUtils.toJsonObject(responseBody));
  338.         } else if (clazz == JSONArray.class) {
  339.             response.setBody(WebbUtils.toJsonArray(responseBody));
  340.         }
  341.     }

  343.     static <T> void parseErrorResponse(Class<T> clazz, Response<T> response, InputStream responseBodyStream)
  344.             throws UnsupportedEncodingException, IOException {

  346.         if (responseBodyStream == null) {
  347.             return;
  348.         } else if (clazz == InputStream.class) {
  349.             response.errorBody = responseBodyStream;
  350.             return;
  351.         }

  353.         byte[] responseBody = WebbUtils.readBytes(responseBodyStream);
  354.         String contentType = response.connection.getContentType();
  355.         if (contentType == null || contentType.startsWith(Const.APP_BINARY) || clazz == Const.BYTE_ARRAY_CLASS) {
  356.             response.errorBody = responseBody;
  357.             return;
  358.         }

  360.         if (contentType.startsWith(Const.APP_JSON) && clazz == JSONObject.class) {
  361.             try {
  362.                 response.errorBody = WebbUtils.toJsonObject(responseBody);
  363.                 return;
  364.             } catch (Exception ignored) {
  365.                 // ignored - was just a try!
  366.             }
  367.         }

  369.         // fallback to String if bytes are valid UTF-8 characters ...
  370.         try {
  371.             response.errorBody = new String(responseBody, Const.UTF8);
  372.             return;
  373.         } catch (Exception ignored) {
  374.             // ignored - was just a try!
  375.         }

  377.         // last fallback - return error object as byte[]
  378.         response.errorBody = responseBody;
  379.     }
  380. }
Created with JaCoCo 0.7.0.201403182114