1  package ru.zoommax;
  2  
  3  import com.sun.net.httpserver.Headers;
  4  import com.sun.net.httpserver.HttpExchange;
  5  import com.sun.net.httpserver.HttpHandler;
  6  import com.sun.net.httpserver.HttpServer;
  7  import org.slf4j.Marker;
  8  import org.slf4j.MarkerFactory;
  9  
 10  import static ru.zoommax.SimpleServer.logger;
 11  
 12  import java.io.IOException;
 13  import java.io.OutputStream;
 14  import java.io.UnsupportedEncodingException;
 15  import java.net.InetSocketAddress;
 16  import java.net.URLDecoder;
 17  import java.util.HashMap;
 18  import java.util.concurrent.ExecutorService;
 19  import java.util.concurrent.Executors;
 20  import java.util.concurrent.TimeUnit;
 21  
 22  /**
 23   * Class for creating http server in second thread,
 24   * adding and removing endpoints, getting request headers and params, getting client ip,
 25   * decoding url, sending response.
 26   * @see Server#endPoint(String, HttpHandler)
 27   * @see Server#remEndPoint(String)
 28   * @see Server#requestHeaders(HttpExchange)
 29   * @see Server#requestParams(String)
 30   * @see Server#getIp(HttpExchange)
 31   * @see Server#decode(String)
 32   * @see Server#run()
 33   * @see Server#Server(int)
 34   * @author ZooMMaX
 35   * @version 1.3
 36   * @since 13.10.23
 37   */
 38  @Deprecated
 39  public class Server implements Runnable{
 40  
 41      /**
 42       * HttpServer object
 43       * @see HttpServer
 44       */
 45      private static HttpServer server;
 46  
 47      /**
 48       * Port number on which the server will be running
 49       */
 50      private int port;
 51  
 52      /**
 53       * Server initialization.<br>For start server use {@link #run()}<br>
 54       * @param port port number on which the server will be running
 55       */
 56      public Server(int port){
 57          this.port = port;
 58      }
 59      public Server(){}
 60  
 61      @Override
 62      public void run() {
 63          try {
 64              server = HttpServer.create(new InetSocketAddress(port), 0);
 65  
 66              server.createContext("/alife", exchange -> {
 67                  logger.info("request to /alife");
 68                  String request = Server.decode(exchange.getRequestURI().getRawQuery());
 69                  logger.info("request: "+request);
 70                  String respText = "life";
 71                  exchange.sendResponseHeaders(200, respText.getBytes().length);
 72                  OutputStream output = exchange.getResponseBody();
 73                  output.write(respText.getBytes());
 74                  output.flush();
 75                  exchange.close();
 76              });
 77  
 78              ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
 79              server.setExecutor(executor); // creates a default executor
 80              server.start();
 81              executor.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);
 82          } catch (IOException e) {
 83              logger.error("IOException", e);
 84          } catch (InterruptedException e) {
 85              logger.error("InterruptedException", e);
 86          }
 87      }
 88  
 89      /**
 90       * Add endpoint to server
 91       * @param endpoint {@link String} endpoint url. Example: "api/v1/test" <b>without root slash</b>
 92       * @param handler {@link HttpHandler} for endpoint. You can use {@link GetHandler} or {@link PostHandler} interfaces.
 93       */
 94      public static void endPoint(String endpoint, HttpHandler handler){
 95          server.createContext(endpoint, handler);
 96          logger.info("add "+endpoint);
 97      }
 98  
 99      /**
100       * Remove endpoint from server
101       * @param endpoint {@link String} endpoint url. Example: "api/v1/test" <b>without root slash</b>
102       */
103      public static void remEndPoint(String endpoint){
104          server.removeContext(endpoint);
105          logger.info("remove "+endpoint);
106      }
107  
108      /**
109       * Decode url. Used in {@link GetHandler} and {@link PostHandler} interfaces.
110       * @param encoded {@link String} encoded url
111       * @return {@link String} decoded url
112       */
113      public static String decode(final String encoded) {
114          try {
115              return encoded == null ? null : URLDecoder.decode(encoded, "UTF-8");
116          } catch (final UnsupportedEncodingException e) {
117              logger.error("UTF-8 is a required encoding", e);
118              return "";
119          }
120      }
121  
122      /**
123       * Get request headers. Used in {@link GetHandler} and {@link PostHandler} interfaces.
124       * @param httpExchange {@link HttpExchange} object
125       * @return {@link HashMap} with headers
126       */
127      public static HashMap<String, String> requestHeaders(HttpExchange httpExchange){
128          Headers exchangeHeaders = httpExchange.getRequestHeaders();
129          HashMap<String, String> headers = new HashMap<>();
130          for(String key: exchangeHeaders.keySet()) {
131              key = key.toLowerCase();
132              headers.put(key, exchangeHeaders.getFirst(key));
133          }
134          return headers;
135      }
136  
137      /**
138       * Get request params. Used in {@link GetHandler} and {@link PostHandler} interfaces.
139       * @param paramsStr {@link String} params string. Example: "param1=value1{@literal &}param2=value2"
140       * @return {@link HashMap} with params
141       */
142      public static HashMap<String, String> requestParams(String paramsStr){
143          HashMap<String, String> params = new HashMap<>();
144          for(String param: paramsStr.split("&")){
145              String[] pair = param.split("=");
146              params.put(pair[0], pair[1]);
147          }
148          return params;
149      }
150  
151      /**
152       * Get client ip. Used in {@link GetHandler} and {@link PostHandler} interfaces.
153       * @param httpExchange {@link HttpExchange} object
154       * @return {@link String} client ip
155       */
156      public static String getIp(HttpExchange httpExchange){
157          HashMap<String,String> headers = requestHeaders(httpExchange);
158          if(headers.containsKey("x-forwarded-for"))
159              return headers.get("x-forwarded-for");
160          else {
161              return httpExchange.getRemoteAddress().getAddress().getHostAddress();
162          }
163      }
164  }