• Home
• org.keeber
• simple-rest
• 0.9.4
• source code
• Rest.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.keeber.http.Rest Maven / Gradle / Ivy

package org.keeber.http;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

public abstract class Rest {
  protected String url;
  protected Map headers = new HashMap();
  protected static final String AUTH = "Authorization";

  /**
   * Create a client instance with the given endpoint.
   * 
   * @param url the endpoint (typically starting with http:// or https://)
   * @return Client
   */
  public static Client newClient(String url) {
    return new Client(url);
  }

  protected Rest(String url) {
    this.url = url;
  }

  private Gson serializer;

  Gson serializer() {
    return this.serializer == null ? serializer = new GsonBuilder().setPrettyPrinting().create() : serializer;
  }

  /**
   * Set the Gson serializer for object operations.
   * 
   * @param serializer Gson instance to use.
   * @return Rest
   */
  public T serializer(Gson serializer) {
    this.serializer = serializer;
    return getThis();
  }

  public T header(String key, String value) {
    headers.put(key, value);
    return getThis();
  }

  protected abstract T getThis();

  /**
   * Removed the designated header from this client (already created requests will be unaffected).
   * 
   * @param key header key to remove eg: "User-agent"
   * @return Rest
   */
  public T clear(String key) {
    headers.remove(key);
    return getThis();
  }

  /**
   * Clear the basic authorization for this client.
   * 
   * @return Rest
   */
  public T nobasic() {
    return clear(AUTH);
  }

  /**
   * Set basic authorization for this client.
   * 
   * @param username User name.
   * @param password Password.
   * @return Rest
   */
  public T basic(String username, String password) {
    return header(AUTH, "Basic " + io.encode(username + ":" + password));
  }

  /**
   * Sets headers for JSON communication (Accept & Content-Type).
   * 
   * @return Rest
   */
  public T json() {
    header("Accept", "application/json");
    header("Content-Type", "application/json");
    return getThis();
  }

  private enum Method {
    POST, GET, PUT, DELETE, HEAD;
  }

  public static class Client extends Rest {

    /**
     * Create a request from this client. The provided URL is appended to the clients endpoint - it
     * may also include route params. Headers from the client (including auth) will be used on
     * execution.
     * 
     * 

     * Requests executions (get(), post(), etc... methods) are thread safe.
     * 
     * @param url the endpoint.
     * @return Request
     */
    public Request newRequest(String url) {
      return new Request(url);
    }

    /**
     * Create a request from this client. Using the base URL for the client. Headers from the client
     * (including auth) will be used on execution.
     * 
     * 

     * Requests executions (get(), post(), etc... methods) are thread safe.
     * 
     * @param url the endpoint.
     * @return Request
     */
    public Request newRequest() {
      return new Request("");
    }

    private Client(String url) {
      super(url);
    }

    public class Request extends Rest {
      private Request(String url) {
        super(url);
      }

      private String query;

      @Override
      protected Request getThis() {
        return this;
      }

      /**
       * Add query parameters to this request - this method will perform URL encoding.
       * 
       * 

       * Query parameters are cumulative (ie: they do not use an underlying map) - however them may
       * contain (or consist entirely of) route parameters in the form of {myparam}.
       * 
       * @param name of the parameter
       * @param value of the parameter
       * @return Request
       */
      public Request query(String name, String value) {
        try {
          query = (query == null ? "?" : query + "&") + name + "=" + URLEncoder.encode(value, io.UTF_8);
        } catch (UnsupportedEncodingException e) {
          throw new RuntimeException(e.getMessage(), e);
        }
        return this;
      }

      /**
       * Add query parameters to this request - this method delegates to {@link #query(String, String)}
       *
       * 

       * When the Optiona value is empty the parameter is ommited from the Request.
       * 
       * @param name of the parameter
       * @param value (optional) of the parameter - allowing it to be null
       * @return Request
       */
      public Request query(String name, Optional