HttpUtil.java

  1. /***************************************************************************
  2.    Copyright 2009 Emily Estes

  4.    Licensed under the Apache License, Version 2.0 (the "License");
  5.    you may not use this file except in compliance with the License.
  6.    You may obtain a copy of the License at

  8.        http://www.apache.org/licenses/LICENSE-2.0

  10.    Unless required by applicable law or agreed to in writing, software
  11.    distributed under the License is distributed on an "AS IS" BASIS,
  12.    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.    See the License for the specific language governing permissions and
  14.    limitations under the License.
  15. ***************************************************************************/
  16. package net.metanotion.web.concrete;


  19. import java.io.ByteArrayOutputStream;
  20. import java.io.IOException;
  21. import java.nio.charset.StandardCharsets;
  22. import java.util.Arrays;
  23. import java.util.Collections;
  24. import java.util.Iterator;
  25. import java.util.List;
  26. import java.util.Map;

  28. import net.metanotion.io.Serializer;
  29. import net.metanotion.util.Pair;
  30. import net.metanotion.util.Wrap;
  31. import net.metanotion.web.Cookie;
  32. import net.metanotion.web.HttpStatus;
  33. import net.metanotion.web.HttpValues;

  35. /** Utilty methods for generating common types of HTTP responses.
  36. This class is just a collection of utility methods for generating many common types of HTTP responses.
  37. */
  38. public final class HttpUtil {
  39.     private static final String HTML_MIME = "text/html; charset=utf-8";
  40.     private static final String JSON_MIME = "application/json; charset=utf-8";
  41.     private static final String CONTENT_TYPE = "Content-Type";
  42.     private static final String LOCATION = "Location";
  43.     /** Many of the SimpleHttpValues instances use an empty list. This is just a short cut instead of making a new one
  44.     every time. */
  45.     private static final List<Map.Entry<String,Object>> EMPTY_LIST = (List<Map.Entry<String,Object>>) Collections.EMPTY_LIST;
  46.     /** Many common responses just need to send a header list with a Content-Type set to UTF-8 encoded HTML. */
  47.     private static final List<Map.Entry<String,Object>> BASIC_HEADER_LIST =
  48.         Collections.unmodifiableList(Arrays.asList((Map.Entry<String,Object>) new Pair<String,Object>(CONTENT_TYPE, HTML_MIME)));
  49.     /** All the basic JSON responses need the Content-Type set to JSON. */
  50.     private static final List<Map.Entry<String,Object>> JSON_HEADER_LIST =
  51.         Collections.unmodifiableList(Arrays.asList((Map.Entry<String,Object>) new Pair<String,Object>(CONTENT_TYPE, JSON_MIME)));
  52.     private static final String EMPTY_STRING = "";

  54.     /** Generate an HTTP response that simply returns an HTTP Status code with blank content.
  55.         @param status The HTTP status code to return.
  56.         @return An HttpValues instance encoding the response.
  57.     */
  58.     public static HttpValues newStatus(final int status) {
  59.         return new SimpleHttpValues(HttpUtil.BASIC_HEADER_LIST, HttpUtil.EMPTY_LIST, HttpUtil.EMPTY_STRING, status);
  60.     }

  62.     /** Issue temporary redirect(303) to another url.
  63.         @param url The URL to redirect the request to.
  64.         @return An HttpValues instance encoding the response.
  65.     */
  66.     public static HttpValues newRedirect(final String url) {
  67.         return new SimpleHttpValues(Arrays.asList((Map.Entry<String,Object>) new Pair<String,Object>(LOCATION, url)),
  68.                                         HttpUtil.EMPTY_LIST,
  69.                                         HttpUtil.EMPTY_STRING,
  70.                                         HttpStatus.REDIRECT_SEE_OTHER.codeNumber());
  71.     }

  73.     /** Issue a redirect by code number(actually, this just sets the Location header and uses whatever code number you
  74.         give it, but it should be one of the 3xx codes to actually work correctly.
  75.         @param url The URL to redirect the request to.
  76.         @param type The HTTP status code of the response.
  77.         @return An HttpValues instance encoding the response.
  78.     */
  79.     public static HttpValues newRedirect(final String url, final HttpStatus type) {
  80.         return new SimpleHttpValues(Arrays.asList((Map.Entry<String,Object>) new Pair<String,Object>(LOCATION, url)),
  81.                                         HttpUtil.EMPTY_LIST,
  82.                                         HttpUtil.EMPTY_STRING,
  83.                                         type.codeNumber());
  84.     }

  86.     /** Generate a 404 Not found response.
  87.         @param message The content(presumed to be HTML) to send with the response.
  88.         @return An HttpValues instance encoding the response.
  89.     */
  90.     public static HttpValues new404(final String message) {
  91.         return new SimpleHttpValues(HttpUtil.BASIC_HEADER_LIST, HttpUtil.EMPTY_LIST, message, HttpStatus.NOT_FOUND.codeNumber());
  92.     }

  94.     /** Generate a 403 Forbidden response.
  95.         @param message The content(presumed to be HTML) to send with the response.
  96.         @return An HttpValues instance encoding the response.
  97.     */
  98.     public static HttpValues new403(final String message) {
  99.         return new SimpleHttpValues(HttpUtil.BASIC_HEADER_LIST, HttpUtil.EMPTY_LIST, message, HttpStatus.FORBIDDEN.codeNumber());
  100.     }

  102.     /** Generate a 500 internal server error response.
  103.         @param message The content(presumed to be HTML) to send with the response.
  104.         @return An HttpValues instance encoding the response.
  105.     */
  106.     public static HttpValues new500(final String message) {
  107.         return new SimpleHttpValues(HttpUtil.BASIC_HEADER_LIST,
  108.             HttpUtil.EMPTY_LIST,
  109.             message,
  110.             HttpStatus.SERVER_ERROR.codeNumber());
  111.     }

  113.     /** Send back an HTML response. This is a "normal" response with a status of 200 "OK".
  114.         @param html The content, presumed to be HTML.
  115.         @return An HttpValues instance encoding the response.
  116.     */
  117.     public static HttpValues newHtmlString(final String html) {
  118.         return new SimpleHttpValues(HttpUtil.BASIC_HEADER_LIST, HttpUtil.EMPTY_LIST, html);
  119.     }

  121.     /** Send a basic response to the client with a custom MIME type and a status of 200 "OK".
  122.         @param content A object encoding a representation of the content suitable for issuing as a reply(as a fallback,
  123.             {@link java.lang.Object#toString} is used to generate a representation of the content to send to the
  124.             client).
  125.         @param contentType The MIME-type to set for the value of the Content-Type header.
  126.         @return An HttpValues instance encoding the response.
  127.     */
  128.     public static HttpValues newTypedContent(final Object content, final String contentType) {
  129.         return new SimpleHttpValues(
  130.             Arrays.asList((Map.Entry<String,Object>) new Pair<String,Object>(CONTENT_TYPE, contentType)),
  131.             HttpUtil.EMPTY_LIST,
  132.             content);
  133.     }

  135.     /** Generate a JSON response, and send it with 200 OK status.
  136.         @param content A JSON object or an encoding of a JSON object suitable for issuing as a reply(as a fallback,
  137.             {@link java.lang.Object#toString} is used to generate a representation of the content to send to the
  138.             client).
  139.         @return An HttpValues instance encoding the response.
  140.     */
  141.     public static HttpValues newJsonResponse(final Object content) {
  142.         return newJsonResponse(content, HttpStatus.OK.codeNumber());
  143.     }

  145.     /** Generate a JSON response with a custom status.
  146.         @param content A JSON object or an encoding of a JSON object suitable for issuing as a reply(as a fallback,
  147.             {@link java.lang.Object#toString} is used to generate a representation of the content to send to the
  148.             client).
  149.         @param type The HTTP status code of the response.
  150.         @return An HttpValues instance encoding the response.
  151.     */
  152.     public static HttpValues newJsonResponse(final Object content, final int type) {
  153.         return new SimpleHttpValues(HttpUtil.JSON_HEADER_LIST, HttpUtil.EMPTY_LIST, content, type);
  154.     }

  156.     /** Convert an HTTP response object into a printable string for debugging purposes. This uses the same algorithm as
  157.     the framework does in {@link net.metanotion.web.servlets.RequestHandler}
  158.         @param result The HTTP response to serialize.
  159.         @return a string representing the HTTP response.
  160.         @throws IOException if there is a problem serializing the response.
  161.     */
  162.     public static String debugString(final Object result) throws IOException {
  163.         final StringBuilder sb = new StringBuilder("");
  164.         if(result == null) { return "NULL"; }
  165.         if(result instanceof HttpValues) {
  166.             final HttpValues hv = (HttpValues) result;
  167.             sb.append("HTTP " + Integer.toString(hv.getHttpStatus()) + "\n");
  168.             for(final Iterator<Map.Entry<String,Object>> it = hv.listHeaders(); it.hasNext();) {
  169.                 final Map.Entry<String,Object> e = it.next();
  170.                 sb.append("HEADER: " + e.getKey() + " = " + e.getValue().toString() + "\n");
  171.             }
  172.             for(final Iterator<Map.Entry<String,Object>> it = hv.listCookies(); it.hasNext();) {
  173.                 final Map.Entry<String,Object> e = it.next();
  174.                 sb.append("COOKIE: " + e.getKey() + " = '");
  175.                 final Object val = e.getValue();
  176.                 sb.append(((val instanceof Cookie) ? ((Cookie) val).getValue() : val.toString()) + "'\n");
  177.             }
  178.         }
  179.         final Object content = (result instanceof Wrap) ? ((Wrap) result).unwrap() : result;
  180.         final ByteArrayOutputStream baos = new ByteArrayOutputStream();
  181.         Serializer.write(content, baos, StandardCharsets.UTF_8);
  182.         return sb.append(new String(baos.toByteArray(), StandardCharsets.UTF_8)).toString();
  183.     }
  184. }
Created with JaCoCo 0.7.5.201505241946