How to use

HttpServer

in

com.sun.net.httpserver

public SimpleEurekaHttpServer(EurekaHttpClient requestHandler, EurekaTransportEventListener eventListener) throws IOException {
  this.requestHandler = requestHandler;
  this.eventListener = eventListener;
  this.httpServer = HttpServer.create(new InetSocketAddress(0), 1);
  httpServer.createContext("/v2", createEurekaV2Handle());
  httpServer.setExecutor(null);
  httpServer.start();
}

@Override
public void destroy() {
  logger.info("Stopping HttpServer");
  this.server.stop(this.shutdownDelay);
}

public int getServerPort() {
  return httpServer.getAddress().getPort();
}

@Override
public void afterPropertiesSet() throws Exception {
  if (this.server == null) {
    InetSocketAddress address = (this.hostname != null ?
        new InetSocketAddress(this.hostname, this.port) : new InetSocketAddress(this.port));
    HttpServer server = HttpServer.create(address, this.backlog);
    if (logger.isInfoEnabled()) {
      logger.info("Starting HttpServer at address " + address);
    }
    server.start();
    this.server = server;
    this.localServer = true;
  }
  super.afterPropertiesSet();
}

@Override
public void start() {
  if (started.compareAndSet(false, true)) {
    LOGGER.log(Level.FINE, "Starting JdkHttpServerTestContainer...");
    server.start();
    if (baseUri.getPort() == 0) {
      baseUri = UriBuilder.fromUri(baseUri)
          .port(server.getAddress().getPort())
          .build();
      LOGGER.log(Level.INFO, "Started JdkHttpServerTestContainer at the base URI " + baseUri);
    }
  } else {
    LOGGER.log(Level.WARNING, "Ignoring start request - JdkHttpServerTestContainer is already started.");
  }
}

/**
 * Create the HttpServer to use. Can be overridden if a custom or already existing HttpServer should be
 * used
 *
 * @return HttpServer to use
 * @throws IOException if something fails during the initialisation
 */
private HttpServer createHttpServer(JolokiaServerConfig pConfig) throws IOException {
  int port = pConfig.getPort();
  InetAddress address = pConfig.getAddress();
  InetSocketAddress socketAddress = new InetSocketAddress(address,port);
  HttpServer server = pConfig.useHttps() ?
          createHttpsServer(socketAddress, pConfig) :
          HttpServer.create(socketAddress, pConfig.getBacklog());
  // Thread factory which creates only daemon threads
  ThreadFactory daemonThreadFactory = new DaemonThreadFactory(pConfig.getThreadNamePrefix());
  // Prepare executor pool
  Executor executor;
  String mode = pConfig.getExecutor();
  if ("fixed".equalsIgnoreCase(mode)) {
    executor = Executors.newFixedThreadPool(pConfig.getThreadNr(), daemonThreadFactory);
  } else if ("cached".equalsIgnoreCase(mode)) {
    executor = Executors.newCachedThreadPool(daemonThreadFactory);
  } else {
    executor = Executors.newSingleThreadExecutor(daemonThreadFactory);
  }
  server.setExecutor(executor);
  return server;
}

private HttpServer startServer(int port, HttpHandler handler)
  throws IOException {
 final HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
 server.createContext(URI_PATH, handler);
 new Thread(new Runnable() {
  @Override
  public void run() {
   server.start();
  }
 }).start();
 return server;
}

/**
 * Start a HTTP server serving Prometheus metrics from the given registry.
 */
public HTTPServer(InetSocketAddress addr, CollectorRegistry registry, boolean daemon) throws IOException {
  server = HttpServer.create();
  server.bind(addr, 3);
  HttpHandler mHandler = new HTTPMetricHandler(registry);
  server.createContext("/", mHandler);
  server.createContext("/metrics", mHandler);
  executorService = Executors.newFixedThreadPool(5, NamedDaemonThreadFactory.defaultThreadFactory(daemon));
  server.setExecutor(executorService);
  start(daemon);
}

/**
 * Returns base server url in the form <i>protocol://serverHostName:serverPort</i>.
 *
 * @return Base server url.
 */
public String getBaseUrl() {
  return proto + "://" + httpSrv.getAddress().getHostName() + ":" + httpSrv.getAddress().getPort();
}

private String detectAgentUrl(HttpServer pServer, JolokiaServerConfig pConfig, String pContextPath) {
  serverAddress= pServer.getAddress();
  InetAddress realAddress;
  int port;
  if (serverAddress != null) {
    realAddress = serverAddress.getAddress();
    if (realAddress.isAnyLocalAddress()) {
      try {
        realAddress = NetworkUtil.getLocalAddress();
      } catch (IOException e) {
        try {
          realAddress = InetAddress.getLocalHost();
        } catch (UnknownHostException e1) {
          // Ok, ok. We take the original one
          realAddress = serverAddress.getAddress();
        }
      }
    }
    port = serverAddress.getPort();
  } else {
    realAddress = pConfig.getAddress();
    port = pConfig.getPort();
  }
  return String.format("%s://%s:%d%s",
             pConfig.getProtocol(),realAddress.getHostAddress(),port, pContextPath);
}

@Override
public void init() {
  int port = CC.mp.net.cfg.getInt("alloc-server-port");
  boolean https = "https".equals(CC.mp.net.cfg.getString("alloc-server-protocol"));
  this.httpServer = HttpServerCreator.createServer(port, https);
  this.allocHandler = new AllocHandler();
  this.pushHandler = new PushHandler();
  httpServer.setExecutor(Executors.newCachedThreadPool());//设置线程池，由于是纯内存操作，不需要队列
  httpServer.createContext("/", allocHandler);//查询mpush机器
  httpServer.createContext("/push", pushHandler);//模拟发送push
  httpServer.createContext("/index.html", new IndexPageHandler());//查询mpush机器
}

public void start(InetSocketAddress address) throws IOException {
  server = HttpServer.create(address, Integer.parseInt(System.getProperty(BACKLOG, "10")));
  // threadpool!
  server.setExecutor(Executors.newWorkStealingPool(Integer.parseInt(System.getProperty(HTTPPOOL, "10"))));
  // Only two handlers.
  server.createContext("/", new MsgHandler());
  server.createContext("/status", new StatusHandler());
  logger.info("Server started on {} ", server.getAddress());
  // Starts in separate thread.
  server.start();
}

private static void startupHttpMain() {
  try {
    ConsoleProxyServerFactory factory = getHttpServerFactory();
    if (factory == null) {
      s_logger.error("Unable to load HTTP server factory");
      System.exit(1);
    }
    HttpServer server = factory.createHttpServerInstance(httpListenPort);
    server.createContext("/getscreen", new ConsoleProxyThumbnailHandler());
    server.createContext("/resource/", new ConsoleProxyResourceHandler());
    server.createContext("/ajax", new ConsoleProxyAjaxHandler());
    server.createContext("/ajaximg", new ConsoleProxyAjaxImageHandler());
    server.setExecutor(new ThreadExecutor()); // creates a default executor
    server.start();
  } catch (Exception e) {
    s_logger.error(e.getMessage(), e);
    System.exit(1);
  }
}

/** Starts the thread that runs the Resource Manager server. */
public void start() {
 server.start();
}

@Override
public HttpContext createContext(final String s) {
  return delegate.createContext(s);
}

@Override
public void setExecutor(final Executor executor) {
  delegate.setExecutor(executor);
}

  @Override
  public InetSocketAddress getAddress() {
    return delegate.getAddress();
  }
};

@Override
public void afterPropertiesSet() throws Exception {
  if (this.server == null) {
    InetSocketAddress address = (this.hostname != null ?
        new InetSocketAddress(this.hostname, this.port) : new InetSocketAddress(this.port));
    HttpServer server = HttpServer.create(address, this.backlog);
    if (logger.isInfoEnabled()) {
      logger.info("Starting HttpServer at address " + address);
    }
    server.start();
    this.server = server;
    this.localServer = true;
  }
  super.afterPropertiesSet();
}

private HttpServer startServer(int port, HttpHandler handler)
  throws IOException {
 final HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
 server.createContext(URI_PATH, handler);
 new Thread(new Runnable() {
  @Override
  public void run() {
   server.start();
  }
 }).start();
 servers.add(server);
 return server;
}

/**
 * Start a HTTP server serving Prometheus metrics from the given registry.
 */
public HTTPServer(InetSocketAddress addr, CollectorRegistry registry, boolean daemon) throws IOException {
  server = HttpServer.create();
  server.bind(addr, 3);
  HttpHandler mHandler = new HTTPMetricHandler(registry);
  server.createContext("/", mHandler);
  server.createContext("/metrics", mHandler);
  executorService = Executors.newFixedThreadPool(5, DaemonThreadFactory.defaultThreadFactory(daemon));
  server.setExecutor(executorService);
  start(daemon);
}