Java HttpServer类代码示例

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
public void delayToObservable(HttpServer server) {
  server.requestHandler(request -> {
    if (request.method() == HttpMethod.POST) {

      // Stop receiving buffers
      request.pause();

      checkAuth(res -> {

        // Now we can receive buffers again
        request.resume();

        if (res.succeeded()) {
          Observable<Buffer> observable = request.toObservable();
          observable.subscribe(buff -> {
            // Get buffers
          });
        }
      });
    }
  });
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testDeploy() throws Exception {
  AtomicInteger count = new AtomicInteger();
  vertx.deployVerticle(new AbstractVerticle() {
    @Override
    public void start() throws Exception {
      HttpServer s1 = vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(req -> {
      });
      HttpServer s2 = vertx.createHttpServer(new HttpServerOptions().setPort(8081)).requestHandler(req -> {
      });
      Observable<HttpServer> f1 = s1.listenObservable();
      Observable<HttpServer> f2 = s2.listenObservable();
      Action1<HttpServer> done = server -> {
        if (count.incrementAndGet() == 2) {
          testComplete();
        }
      };
      f1.subscribe(done);
      f2.subscribe(done);
    }
  });
  await();
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testObserverToFuture() {
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(req -> {});
  AtomicInteger count = new AtomicInteger();
  Observer<HttpServer> observer = new Observer<HttpServer>() {
    @Override
    public void onCompleted() {
      server.close();
      assertEquals(1, count.get());
      testComplete();
    }

    @Override
    public void onError(Throwable e) {
      fail(e.getMessage());
    }

    @Override
    public void onNext(HttpServer httpServer) {
      count.incrementAndGet();
    }
  };
  Observable<HttpServer> onListen = server.listenObservable();
  onListen.subscribe(observer);
  await();
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testHttpClient() {
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.requestStream().handler(req -> {
    req.response().setChunked(true).end("some_content");
  });
  try {
    server.listen(ar -> {
      HttpClient client = vertx.createHttpClient(new HttpClientOptions());
      client.request(HttpMethod.GET, 8080, "localhost", "/the_uri", resp -> {
        Buffer content = Buffer.buffer();
        Observable<Buffer> observable = resp.toObservable();
        observable.forEach(content::appendBuffer, err -> fail(), () -> {
          assertEquals("some_content", content.toString("UTF-8"));
          testComplete();
        });
      }).end();
    });
    await();
  } finally {
    server.close();
  }
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testWebsocketClient() {
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.websocketStream().handler(ws -> {
    ws.write(Buffer.buffer("some_content"));
    ws.close();
  });
  server.listen(ar -> {
    HttpClient client = vertx.createHttpClient(new HttpClientOptions());
    client.websocket(8080, "localhost", "/the_uri", ws -> {
      Buffer content = Buffer.buffer();
      Observable<Buffer> observable = ws.toObservable();
      observable.forEach(content::appendBuffer, err -> fail(), () -> {
        server.close();
        assertEquals("some_content", content.toString("UTF-8"));
        testComplete();
      });
    });
  });
  await();
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testWebsocketClientFlatMap() {
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.websocketStream().handler(ws -> {
    ws.write(Buffer.buffer("some_content"));
    ws.close();
  });
  server.listen(ar -> {
    HttpClient client = vertx.createHttpClient(new HttpClientOptions());
    Buffer content = Buffer.buffer();
    client.
        websocketStream(8080, "localhost", "/the_uri").
        toObservable().
        flatMap(WebSocket::toObservable).
        forEach(content::appendBuffer, err -> fail(), () -> {
          server.close();
          assertEquals("some_content", content.toString("UTF-8"));
          testComplete();
        });
  });
  await();
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testGet() {
  int times = 5;
  waitFor(times);
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.requestStream().handler(req -> req.response().setChunked(true).end("some_content"));
  try {
    server.listen(ar -> {
      client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions()));
      Single<HttpResponse<Buffer>> single = client
        .get(8080, "localhost", "/the_uri")
        .as(BodyCodec.buffer())
        .rxSend();
      for (int i = 0; i < times; i++) {
        single.subscribe(resp -> {
          Buffer body = resp.body();
          assertEquals("some_content", body.toString("UTF-8"));
          complete();
        }, this::fail);
      }
    });
    await();
  } finally {
    server.close();
  }
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testPost() {
  int times = 5;
  waitFor(times);
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.requestStream().handler(req -> req.bodyHandler(buff -> {
    assertEquals("onetwothree", buff.toString());
    req.response().end();
  }));
  try {
    server.listen(ar -> {
      client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions()));
      Observable<Buffer> stream = Observable.just(Buffer.buffer("one"), Buffer.buffer("two"), Buffer.buffer("three"));
      Single<HttpResponse<Buffer>> single = client
        .post(8080, "localhost", "/the_uri")
        .rxSendStream(stream);
      for (int i = 0; i < times; i++) {
        single.subscribe(resp -> complete(), this::fail);
      }
    });
    await();
  } finally {
    server.close();
  }
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testResponseMissingBody() throws Exception {
  int times = 5;
  waitFor(times);
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.requestStream().handler(req -> req.response().setStatusCode(403).end());
  try {
    server.listen(ar -> {
      client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions()));
      Single<HttpResponse<Buffer>> single = client
        .get(8080, "localhost", "/the_uri")
        .rxSend();
      for (int i = 0; i < times; i++) {
        single.subscribe(resp -> {
          assertEquals(403, resp.statusCode());
          assertNull(resp.body());
          complete();
        }, this::fail);
      }
    });
    await();
  } finally {
    server.close();
  }
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Test
public void testResponseBodyAsAsJsonMapped() throws Exception {
  JsonObject expected = new JsonObject().put("cheese", "Goat Cheese").put("wine", "Condrieu");
  HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080));
  server.requestStream().handler(req -> req.response().end(expected.encode()));
  try {
    server.listen(ar -> {
      client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions()));
      Single<HttpResponse<WineAndCheese>> single = client
        .get(8080, "localhost", "/the_uri")
        .as(BodyCodec.json(WineAndCheese.class))
        .rxSend();
      single.subscribe(resp -> {
        assertEquals(200, resp.statusCode());
        assertEquals(new WineAndCheese().setCheese("Goat Cheese").setWine("Condrieu"), resp.body());
        testComplete();
      }, this::fail);
    });
    await();
  } finally {
    server.close();
  }
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
private Single<HttpServer> initHttpServer(Router router, JDBCClient client) {
  store = new JdbcProductStore(client);
  // Create the HTTP server and pass the "accept" method to the request handler.
  return vertx
    .createHttpServer()
    .requestHandler(router::accept)
    .rxListen(8080);
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
@Override
public void start(Future<Void> startFuture) {
  // deploy the web server
  HttpServerOptions options = new HttpServerOptions()
      .setCompressionSupported(true);
  HttpServer server = vertx.createHttpServer(options);
  server.requestHandler(this::onRequest);
  server.listenObservable(8080) // listen on port 8080
    .subscribe(v -> startFuture.complete(), startFuture::fail);
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
private Single<HttpServer> configureTheHTTPServer() {
  //----
  // Use a Vert.x Web router for this REST API.
  Router router = Router.router(vertx);
  router.get("/").handler(this::retrieveOperations);
  HttpServer server = vertx.createHttpServer().requestHandler(router::accept);
  Integer port = config().getInteger("http.port", 0);
  return server.rxListen(port);
  //----
}
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
private Single<HttpServer> configureTheHTTPServer() {

    //TODO
    //----
    Single<HttpServer> httpServerSingle = Single.error(new UnsupportedOperationException("not yet implemented"));
    //----

    return httpServerSingle;
  }
 

import io.vertx.rxjava.core.http.HttpServer; //导入依赖的package包/类
public void websocketServer(HttpServer server) {
  Observable<ServerWebSocket> socketObservable = server.websocketStream().toObservable();
  socketObservable.subscribe(
      socket -> System.out.println("Web socket connect"),
      failure -> System.out.println("Should never be called"),
      () -> {
        System.out.println("Subscription ended or server closed");
      }
  );
}