Java Code Examples for com.sun.net.httpserver.HttpExchange

@Override
public void handle(HttpExchange he) throws IOException {
    if (RCHandler.isLoggedOn(he.getRemoteAddress().getAddress().toString())) {
        if (pageContent == null || !USE_CACHE) {
            pageContent = readFile("server/defaultrcspage.htm");
            pageContent = langStrings(pageContent);
        }
        byte[] bytes = pageContent.getBytes(Charset.forName("UTF-8"));
        he.sendResponseHeaders(200, bytes.length);
        try (OutputStream os = he.getResponseBody()) {
            os.write(bytes);
        }
    } else {
        passwordPage(he);
    }
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    switch(count) {
        case 0:
            AuthenticationHandler.proxyReply(exchange,
                    "Basic realm=\"proxy\"");
            break;
        case 1:
            t3cond1.countDown();
            AuthenticationHandler.errorReply(exchange,
                    "Basic realm=\"realm4\"");
            break;
        case 2:
            AuthenticationHandler.okReply(exchange);
            break;
        default:
            System.out.println ("Unexpected request");
    }
}
 

public void testWithReturnJackson() throws IOException, InterruptedException, ExecutionException {
    CountDownLatch latch = new CountDownLatch(1);
    int port = 9005;

    Stereotypes.def().embeddedHttpServer(port, (HttpExchange ex) -> {
        latch.countDown();
        System.out.println(ex.getRequestURI().getQuery());

        return "{\"number\":\"+47012345678\"}";
    });

    var user = new User("TestUser");
    var phone = new PhoneNumber("+47012345678");
    var actor = ActorSystem.anonymous().<User, PhoneNumber>newRemoteActorWithReturn("actor2", new HttpChannel("http://localhost:" + port + "/", HttpChannel.HttpMethod.GET, null, null, false), new JacksonSerDeser<>(PhoneNumber.class));
    var result = actor.sendMessageReturn(user);

    latch.await(1, TimeUnit.SECONDS);
    System.out.println(result.get());
    Assert.assertEquals(phone, result.get());
}
 

/**
 * Processes the incoming Hessian request and creates a Hessian response.
 */
@Override
public void handle(HttpExchange exchange) throws IOException {
	if (!"POST".equals(exchange.getRequestMethod())) {
		exchange.getResponseHeaders().set("Allow", "POST");
		exchange.sendResponseHeaders(405, -1);
		return;
	}

	ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
	try {
		invoke(exchange.getRequestBody(), output);
	}
	catch (Throwable ex) {
		exchange.sendResponseHeaders(500, -1);
		logger.error("Hessian skeleton invocation failed", ex);
		return;
	}

	exchange.getResponseHeaders().set("Content-Type", CONTENT_TYPE_HESSIAN);
	exchange.sendResponseHeaders(200, output.size());
	FileCopyUtils.copy(output.toByteArray(), exchange.getResponseBody());
}
 

@Override
public void handle(HttpExchange httpExchange) throws IOException {
  // get the entire stuff
  byte[] payload = NetworkUtils.readHttpRequestBody(httpExchange);
  T req;
  try {
    req = parseRequest(payload);
  } catch (InvalidProtocolBufferException e) {
    LOG.log(Level.SEVERE,
        "Unable to decipher data specified in Request: " + httpExchange, e);
    httpExchange.sendResponseHeaders(400, -1); // throw exception
    return;
  }
  U res = generateResponse(req, metricsCache);
  NetworkUtils.sendHttpResponse(httpExchange, res.toByteArray());
  httpExchange.close();
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    try {
        switch(count) {
            case 0:
                AuthenticationHandler.errorReply(exchange,
                        "Basic realm=\"realm1\"");
                break;
            case 1:
                t1Cond1.await();
                AuthenticationHandler.okReply(exchange);
                break;
            default:
                System.out.println ("Unexpected request");
        }
    } catch (InterruptedException |
                     BrokenBarrierException e)
            {
                throw new RuntimeException(e);
            }
}
 

@Override
public void handle(HttpExchange t) throws IOException {
    InputStream is = t.getRequestBody();
    while (is.read() != -1);
    is.close();

    t.sendResponseHeaders (200, 0);
    OutputStream os = t.getResponseBody();
    DigestOutputStream dos = new DigestOutputStream(os, serverDigest);

    int offset = 0;
    for (int i=0; i<52; i++) {
        dos.write(baMessage, offset, CHUNK_SIZE);
        offset += CHUNK_SIZE;
    }
    serverMac = serverDigest.digest();
    os.close();
    t.close();
}
 

public static String addSongToSchedule(HttpExchange he) {
    String songIDString;
    long songID;
    if (he.getRequestURI().toString().contains("/add/")) {
        songIDString = he.getRequestURI().toString().split("/add/", 2)[1];
        songID = Long.parseLong(songIDString);
        SongDisplayable sd = SongManager.get().getIndex().getByID(songID);

        Utils.fxRunAndWait(() -> {
            QueleaApp.get().getMainWindow().getMainPanel().getSchedulePanel().getScheduleList().add(sd);
        });

        return LabelGrabber.INSTANCE.getLabel("rcs.add.success");
    }
    return LabelGrabber.INSTANCE.getLabel("rcs.add.failed");
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    try {
        switch(count) {
            case 0:
                AuthenticationHandler.errorReply(exchange,
                        "Basic realm=\"realm1\"");
                break;
            case 1:
                t1Cond1.await();
                t1cond2latch.await();
                AuthenticationHandler.okReply(exchange);
                break;
            default:
                System.out.println ("Unexpected request");
        }
    } catch (InterruptedException |
                     BrokenBarrierException e)
            {
                throw new RuntimeException(e);
            }
}
 

@SuppressWarnings("unchecked")
@Override
public void handle(HttpExchange httpExchange) throws IOException {
    String body = new String(readBody(httpExchange), Constants.UTF_8);
    Map<String, Object> params = Jsons.fromJson(body, Map.class);

    sendPush(params);

    byte[] data = "服务已经开始推送,请注意查收消息".getBytes(Constants.UTF_8);
    httpExchange.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8");
    httpExchange.sendResponseHeaders(200, data.length);//200, content-length
    OutputStream out = httpExchange.getResponseBody();
    out.write(data);
    out.close();
    httpExchange.close();
}
 

public static String getSongTranslation(HttpExchange he) throws UnsupportedEncodingException {
    String language;
    StringBuilder ret = new StringBuilder();
    if (he.getRequestURI().toString().contains("/gettranslation/")) {
        String uri = URLDecoder.decode(he.getRequestURI().toString(), "UTF-8");
        language = uri.split("/gettranslation/", 2)[1];
        final MainPanel p = QueleaApp.get().getMainWindow().getMainPanel();
        int current = p.getSchedulePanel().getScheduleList().getItems().indexOf(p.getLivePanel().getDisplayable());
        SongDisplayable d = ((SongDisplayable) QueleaApp.get().getMainWindow().getMainPanel().getSchedulePanel().getScheduleList().getItems().get(current));
        for (String b : d.getTranslations().keySet()) {
            if (b.equals(language)) {
                ret.append(d.getTranslations().get(language));
            }
        }
    }
    return ret.toString();
}
 

void handleJstat(HttpExchange t, Map<String, String> paramMap) throws IOException {
    String workerPort = paramMap.get(HttpserverUtils.HTTPSERVER_LOGVIEW_PARAM_WORKER_PORT);
    if (workerPort == null) {
        handlFailure(t, "worker port is not set!");
        return;
    }

    LOG.info("Begin to get jstat of " + workerPort);
    StringBuilder sb = new StringBuilder();
    List<Integer> pids = Worker.getOldPortPids(workerPort);
    for (Integer pid : pids) {
        sb.append("!!!!!!!!!!!!!!!!!!\r\n");
        sb.append("WorkerPort:" + workerPort + ", pid:" + pid);
        sb.append("\r\n!!!!!!!!!!!!!!!!!!\r\n");

        handleJstat(sb, pid);
    }

    byte[] data = sb.toString().getBytes();
    sendResponse(t, HttpURLConnection.HTTP_OK, data);
}
 

@Override
public void handlePost(final HttpExchange exchange) throws IOException, SQLiteException {
    final Account account = verifySession(exchange, false, null);
    if (account == null) {
        return;
    }
    exchange.getResponseHeaders().set("Content-Type", "image/png");
    exchange.sendResponseHeaders(200, 0);
    try (final OutputStream output = exchange.getResponseBody()) {
        final String contents = "attestation.app " +
            account.userId + " " +
            BaseEncoding.base64().encode(account.subscribeKey) + " " +
            account.verifyInterval;
        createQrCode(contents.getBytes(), output);
    }
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    switch(count) {
        case 0:
            AuthenticationHandler.errorReply(exchange,
                    "Basic realm=\"realm2\"");
            try {
                t1Cond2.await();
            } catch (InterruptedException |
                     BrokenBarrierException e)
            {
                throw new RuntimeException(e);
            }
            t1cond2latch.countDown();
            break;
        case 1:
            AuthenticationHandler.okReply(exchange);
            break;
        default:
            System.out.println ("Unexpected request");
    }
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    try {
        switch(count) {
            case 0:
                AuthenticationHandler.errorReply(exchange,
                        "Basic realm=\"realm2\"");
                break;
            case 1:
                t1Cond1.await();
                AuthenticationHandler.okReply(exchange);
                break;
            default:
                System.out.println ("Unexpected request");
        }
    } catch (InterruptedException | BrokenBarrierException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public void handle(HttpExchange t) throws IOException {
    InputStream is = t.getRequestBody();
    byte[] ba = new byte[BUFFER_SIZE];
    int read;
    long count = 0L;
    while((read = is.read(ba)) != -1) {
        count += read;
    }
    is.close();

    check(count == expected, "Expected: " + expected + ", received "
            + count);

    debug("Received " + count + " bytes");

    t.sendResponseHeaders(200, -1);
    t.close();
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {

  // read the http request payload
  byte[] requestBody = NetworkUtils.readHttpRequestBody(exchange);

  // prepare the kill topology request
  Scheduler.KillTopologyRequest killTopologyRequest =
      Scheduler.KillTopologyRequest.newBuilder()
          .mergeFrom(requestBody)
          .build();

  if (!scheduler.onKill(killTopologyRequest)) {
    throw new RuntimeException("Failed to process killTopologyRequest");
  } else {
    throw new TerminateSchedulerException(
        "Kill request handled successfully - terminating scheduler");
  }
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    switch(count) {
        case 0:
            AuthenticationHandler.proxyReply(exchange,
                    "Basic realm=\"proxy\"");
            break;
        case 1:
            t3cond1.countDown();
            AuthenticationHandler.errorReply(exchange,
                    "Basic realm=\"realm4\"");
            break;
        case 2:
            AuthenticationHandler.okReply(exchange);
            break;
        default:
            System.out.println ("Unexpected request");
    }
}
 

/**
 * 处理请求头。
 */
public void handleHeader(HttpExchange httpEx) {
    InetSocketAddress remoteAddress = httpEx.getRemoteAddress();
    _logger.info("收到来自"+remoteAddress.getAddress().getHostAddress()+":"+remoteAddress.getPort()+"的请求");
    
    URI rUri = httpEx.getRequestURI();
    _logger.info("请求地址:"+rUri.toString());
    
    String method = httpEx.getRequestMethod();
    _logger.info("请求方法:"+method);
    
    Headers headers = httpEx.getRequestHeaders();
    Set<Entry<String, List<String>>> headerSet = headers.entrySet();
    _logger.info("请求头:");
    for (Entry<String, List<String>> header : headerSet) {
        _logger.info(header.getKey()+":"+header.getValue());
    }
}
 

public void doFilter(HttpExchange t, Chain chain) throws IOException {
   if (this.authenticator != null) {
      Result r = this.authenticator.authenticate(t);
      if (r instanceof Success) {
         Success s = (Success)r;
         ExchangeImpl e = ExchangeImpl.get(t);
         e.setPrincipal(s.getPrincipal());
         chain.doFilter(t);
      } else if (r instanceof Retry) {
         Retry ry = (Retry)r;
         this.consumeInput(t);
         t.sendResponseHeaders(ry.getResponseCode(), -1L);
      } else if (r instanceof Failure) {
         Failure f = (Failure)r;
         this.consumeInput(t);
         t.sendResponseHeaders(f.getResponseCode(), -1L);
      }
   } else {
      chain.doFilter(t);
   }

}
 

@Override
public void handle(HttpExchange httpExchange) throws IOException {
    Headers headers = httpExchange.getResponseHeaders();
    headers.add("Content-Type", "text/xml");

    //response payload
    String response = "<a></b>";

    httpExchange.sendResponseHeaders(200, response.length());
    OutputStream responseStream = httpExchange.getResponseBody();
    try {
        responseStream.write(response.getBytes(Charset.defaultCharset()));
    } finally {
        responseStream.close();
    }
}
 

public void handle(HttpExchange httpExchange) throws IOException {
    Headers headers = httpExchange.getResponseHeaders();
    headers.add("Content-Type", "text/xml");
    String response = "This is Response status code test case";
    httpExchange.sendResponseHeaders(responseCode, response.length());
    OutputStream os = httpExchange.getResponseBody();
    os.write(response.getBytes());
    os.close();
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    if (count == 1) {
        t2condlatch.countDown();
    }
    AuthenticationHandler.errorReply(exchange,
            "Basic realm=\"realm3\"");

}
 

/**
 * Reads a remote invocation from the request, executes it,
 * and writes the remote invocation result to the response.
 * @see #readRemoteInvocation(HttpExchange)
 * @see #invokeAndCreateResult(RemoteInvocation, Object)
 * @see #writeRemoteInvocationResult(HttpExchange, RemoteInvocationResult)
 */
@Override
public void handle(HttpExchange exchange) throws IOException {
	try {
		RemoteInvocation invocation = readRemoteInvocation(exchange);
		RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
		writeRemoteInvocationResult(exchange, result);
		exchange.close();
	}
	catch (ClassNotFoundException ex) {
		exchange.sendResponseHeaders(500, -1);
		logger.error("Class not found during deserialization", ex);
	}
}
 

private void handleClientKickoff(HttpExchange t, ConsoleProxyClient viewer) throws IOException {
    String response = viewer.onAjaxClientKickoff();
    t.sendResponseHeaders(200, response.length());
    OutputStream os = t.getResponseBody();
    try {
        os.write(response.getBytes());
    } finally {
        os.close();
    }
}
 

@Override
public void handle(HttpExchange he) throws IOException {
    if (RCHandler.isLoggedOn(he.getRemoteAddress().getAddress().toString())) {
        final String response;
        response = RCHandler.songDisplay(he);
        he.getResponseHeaders().add("Cache-Control", "no-cache, no-store, must-revalidate");
        he.sendResponseHeaders(200, response.getBytes(Charset.forName("UTF-8")).length);
        try (OutputStream os = he.getResponseBody()) {
            os.write(response.getBytes(Charset.forName("UTF-8")));
        }
    } else {
        passwordPage(he);
    }
}
 

@Override
public void handle(HttpExchange r) throws IOException {
    String response = "{\"state\":\"NORMAL\",\"nodes\":[{\"isCoordinator\":true, \"id\":\"0f5c2ffc-1244-47d0-a83d-f5a25abba9bc\",\"uri\":{\"scheme\":\"http\",\"host\":\"nonexistent\",\"port\":4444}}],\"localID\":\"0f5c2ffc-1244-47d0-a83d-f5a25abba9bc\"}";
    r.sendResponseHeaders(200, response.getBytes().length);
    try (OutputStream os = r.getResponseBody()) {
        os.write(response.getBytes());
    }
    r.close();
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
    count++;
    switch(count) {
        case 0:
            AuthenticationHandler.errorReply(exchange,
                    "Basic realm=\"realm3\"");
            break;
        case 1:
            AuthenticationHandler.okReply(exchange);
            break;
        default:
            System.out.println ("Unexpected request");
    }
}
 

static void errorReply(HttpExchange exchange, String reply)
        throws IOException
{
    exchange.getResponseHeaders().add("Connection", "close");
    exchange.getResponseHeaders().add("WWW-Authenticate", reply);
    exchange.sendResponseHeaders(401, 0);
    exchange.close();
}
 

@Override
public void handle(HttpExchange t) throws IOException {
    t.sendResponseHeaders(200, message.length());
    BufferedWriter writer = new BufferedWriter( new OutputStreamWriter(t.getResponseBody(), "ISO8859-1"));
    writer.write(message, 0, message.length());
    writer.close();
    t.close();
}