Java CompletableFuture.get方法代碼示例

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
/**
 * Send multisig signature transaction.
 *
 * @param transaction
 *            the transaction
 * @return the nem announce result
 */
public static NemAnnounceResult sendMultisigSignatureTransaction(MultisigSignatureTransaction transaction) {

	final byte[] data = BinarySerializer.serializeToBytes(transaction.asNonVerifiable());

	final RequestAnnounce request = new RequestAnnounce(data, transaction.getSignature().getBytes());
	final CompletableFuture<Deserializer> future = TransactionApi.announceTransaction(NemAppsLibGlobals.getNodeEndpoint(),
			request);
	try {
		Deserializer transDes = future.get();
		return new NemAnnounceResult(transDes);
	} catch (Exception e) {
		LOGGER.warning("Error Occured: " + e.getMessage());
	}
	return null;
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
/**
 * Verifies that inlining continuations works when the option is set.
 */
@Test
public void testSetInlinesContinuationsUnderSwitch() throws Exception {
	event = new AsyncAutoResetEvent(/*allowInliningAwaiters:*/true);
	Thread settingThread = Thread.currentThread();
	final AtomicBoolean setReturned = new AtomicBoolean(false);
	CompletableFuture<Void> inlinedContinuation = event.waitAsync().whenComplete((result, exception) -> {
		// Arrange to synchronously block the continuation until set() has returned,
		// which would deadlock if set() does not return until inlined continuations complete.
		Assert.assertFalse(setReturned.get());
		Assert.assertSame(settingThread, Thread.currentThread());
	});

	event.set();
	setReturned.set(true);
	Assert.assertTrue(inlinedContinuation.isDone());
	// rethrow any exceptions in the continuation
	inlinedContinuation.get(ASYNC_DELAY.toMillis(), TimeUnit.MILLISECONDS);
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test
public void cannotCreateALoanWithoutAction()
  throws MalformedURLException,
  InterruptedException,
  ExecutionException,
  TimeoutException {

  JsonObject loanRequest = new LoanRequestBuilder().create();

  loanRequest.remove("action");

  CompletableFuture<JsonResponse> createCompleted = new CompletableFuture();

  client.post(loanStorageUrl(), loanRequest, StorageTestSuite.TENANT_ID,
    ResponseHandler.json(createCompleted));

  JsonResponse response = createCompleted.get(5, TimeUnit.SECONDS);

  assertThat(String.format("Creating the loan should fail: %s", response.getBody()),
    response.getStatusCode(), is(UNPROCESSABLE_ENTITY));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@AfterClass
public static void after()
  throws InterruptedException, ExecutionException,
  TimeoutException, MalformedURLException {

  removeTenant(TENANT_ID);

  CompletableFuture undeploymentComplete = new CompletableFuture<String>();

  vertx.close(res -> {
    if(res.succeeded()) {
      undeploymentComplete.complete(null);
    }
    else {
      undeploymentComplete.completeExceptionally(res.cause());
    }
  });

  undeploymentComplete.get(20, TimeUnit.SECONDS);
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
/**
 * 3.
 */
public void run3() throws InterruptedException, ExecutionException {
    /**使用supplyAsync()函數執行一個異步任務。接著連續使用流式調用對任務的處理結果進行再加工，直到最後的結果輸出。*/
    CompletableFuture<Void> fu = CompletableFuture
            .supplyAsync(() -> calc(50))
            .thenApply((i) -> Integer.toString(i))
            .thenApply((str) -> "\"" + str + "\"")
            .thenAccept(System.out::println);
    /**等待計算完成*/
    fu.get();

}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test
public void cannotUpdateALoanWithInvalidDates()
  throws InterruptedException,
  MalformedURLException,
  TimeoutException,
  ExecutionException {

  IndividualResource loan = createLoan(loanRequest());

  JsonObject returnedLoan = loan.copyJson();

  returnedLoan.put("loanDate", "bar");
  returnedLoan.put("returnDate", "foo");

  CompletableFuture<TextResponse> putCompleted = new CompletableFuture();

  client.put(loanStorageUrl(String.format("/%s", loan.getId())), returnedLoan,
    StorageTestSuite.TENANT_ID, ResponseHandler.text(putCompleted));

  TextResponse response = putCompleted.get(5, TimeUnit.SECONDS);

  assertThat(String.format("Should have failed to update loan: %s", response.getBody()),
    response.getStatusCode(), is(HttpURLConnection.HTTP_BAD_REQUEST));

  assertThat(response.getBody(),
    containsString("loan date must be a date time (in RFC3339 format)"));

  assertThat(response.getBody(),
    containsString("return date must be a date time (in RFC3339 format)"));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
private JsonResponse putResponse(LoanRules loanRules) throws Exception {
  CompletableFuture<JsonResponse> createCompleted = new CompletableFuture<>();
  client.put(loanRulesStorageUrl(),
    loanRules, StorageTestSuite.TENANT_ID,
    ResponseHandler.json(createCompleted));
  return createCompleted.get(5, TimeUnit.SECONDS);
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test(timeout = 10000)
public void testWatchWithIdentityQuery() throws Exception {
    final Revision rev1 = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, textUpserts[0]).join();

    CompletableFuture<QueryResult<Object>> f =
            repo.watch(rev1, Query.identity(textPaths[0]));

    final Revision rev2 = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, textPatches[1]).join();
    final QueryResult<Object> res = f.get(3, TimeUnit.SECONDS);
    assertThat(res.revision()).isEqualTo(rev2);
    assertThat(res.type()).isEqualTo(EntryType.TEXT);
    // Text must be sanitized so that the last line ends with \n.
    assertThat(res.content()).isEqualTo(textUpserts[1].content() + '\n');
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test
public void canCreateOpenLoanWhenClosedLoansForSameItem()
  throws InterruptedException,
  MalformedURLException,
  TimeoutException,
  ExecutionException {

  UUID itemId = UUID.randomUUID();

  JsonObject closedLoanRequest = new LoanRequestBuilder()
    .withItemId(itemId)
    .withStatus("Closed")
    .create();

  createLoan(closedLoanRequest);

  JsonObject openLoanRequest = new LoanRequestBuilder()
    .withItemId(itemId)
    .withStatus("Open")
    .create();

  CompletableFuture<JsonResponse> createCompleted = new CompletableFuture<>();

  client.post(loanStorageUrl(), openLoanRequest, StorageTestSuite.TENANT_ID,
    ResponseHandler.json(createCompleted));

  JsonResponse response = createCompleted.get(5, TimeUnit.SECONDS);

  assertThat(String.format("Creating the loan should succeed: %s", response.getBody()),
    response.getStatusCode(), is(HttpURLConnection.HTTP_CREATED));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test
public void canSortByNameDescending()
  throws InterruptedException,
  MalformedURLException,
  TimeoutException,
  ExecutionException,
  UnsupportedEncodingException {

  createFixedDueDateSchedule(createFixedDueDate("quarterly"));
  createFixedDueDateSchedule(createFixedDueDate("semester"));
  createFixedDueDateSchedule(createFixedDueDate("semester2"));

  URL sortUrl = dueDateURL("?query=name=*"
    + URLEncoder.encode(" sortBy name/sort.descending", "UTF-8"));

  CompletableFuture<JsonResponse> getCompleted = new CompletableFuture<>();

  client.get(sortUrl, StorageTestSuite.TENANT_ID,
    ResponseHandler.json(getCompleted));

  JsonResponse getResponse = getCompleted.get(5, TimeUnit.SECONDS);

  assertThat(String.format("Failed to get fixed due date schedules: %s",
    getResponse.getJson().encodePrettily()),
    getResponse.getStatusCode(), is(HttpURLConnection.HTTP_OK));

  List<JsonObject> results = JsonArrayHelper.toList(getResponse.getJson()
    .getJsonArray("fixedDueDateSchedules"));

  assertThat(results.size(), is(3));
  assertThat(results.get(0).getString("name"), is("semester2"));
  assertThat(results.get(2).getString("name"), is("quarterly"));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Benchmark
public Void ensureConstN() throws InterruptedException, ExecutionException {
  CompletableFuture<Void> f = constVoidFuture;
  for (int i = 0; i < N.n; i++)
    f = f.thenRun(ensureF);
  return f.get();
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test
public void testWatchWithQuery() throws Exception {
    final Revision rev1 = repo.commit(
            HEAD, 0L, Author.UNKNOWN, SUMMARY,
            Change.ofJsonUpsert(jsonPaths[0], "{ \"hello\": \"mars\" }")).join();

    CompletableFuture<QueryResult<JsonNode>> f =
            repo.watch(rev1, Query.ofJsonPath(jsonPaths[0], "$.hello"));

    // Make sure the initial change does not trigger a notification.
    assertThatThrownBy(() -> f.get(500, TimeUnit.MILLISECONDS))
            .isInstanceOf(TimeoutException.class);

    // Make sure the change that does not affect the query result does not trigger a notification.
    repo.commit(
            HEAD, 0L, Author.UNKNOWN, SUMMARY,
            Change.ofJsonUpsert(jsonPaths[0], "{ \"hello\": \"mars\", \"goodbye\": \"venus\" }"));

    assertThatThrownBy(() -> f.get(500, TimeUnit.MILLISECONDS))
            .isInstanceOf(TimeoutException.class);

    // Here comes the interesting change; make sure notification is triggered.
    final Revision rev3 = repo.commit(
            HEAD, 0L, Author.UNKNOWN, SUMMARY,
            Change.ofJsonUpsert(jsonPaths[0], "{ \"hello\": \"jupiter\", \"goodbye\": \"mars\" }")).join();

    final QueryResult<JsonNode> res = f.get(3, TimeUnit.SECONDS);
    assertThat(res.revision()).isEqualTo(rev3);
    assertThat(res.type()).isEqualTo(EntryType.JSON);
    assertThat(res.content()).isEqualTo(TextNode.valueOf("jupiter"));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Benchmark
public String flatMapPromise() throws InterruptedException, ExecutionException {
  CompletableFuture<String> p = new CompletableFuture<String>();
  p.thenComposeAsync(flatMapF);
  p.complete(string);
  return p.get();
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Ignore("Fails on Mac OS due to differences in UTF-8 collation libraries")
@Test
public void canSortDifferentCaseNamesAscending()
  throws InterruptedException,
  MalformedURLException,
  TimeoutException,
  ExecutionException,
  UnsupportedEncodingException {

  createFixedDueDateSchedule(createFixedDueDate("quarterly"));
  createFixedDueDateSchedule(createFixedDueDate("Semester"));
  createFixedDueDateSchedule(createFixedDueDate("semester2"));

  URL sortUrl = dueDateURL("?query=name=*"
    + URLEncoder.encode(" sortBy name/sort.ascending", "UTF-8"));

  CompletableFuture<JsonResponse> getCompleted = new CompletableFuture<>();

  client.get(sortUrl, StorageTestSuite.TENANT_ID,
    ResponseHandler.json(getCompleted));

  JsonResponse getResponse = getCompleted.get(5, TimeUnit.SECONDS);

  assertThat(String.format("Failed to get fixed due date schedules: %s",
    getResponse.getJson().encodePrettily()),
    getResponse.getStatusCode(), is(HttpURLConnection.HTTP_OK));

  List<JsonObject> results = JsonArrayHelper.toList(getResponse.getJson()
    .getJsonArray("fixedDueDateSchedules"));

  results.stream()
    .map(result -> result.getString("name"))
    .forEachOrdered(System.out::println);

  assertThat(results.size(), is(3));
  assertThat(results.get(0).getString("name"), is("quarterly"));
}
 

import java.util.concurrent.CompletableFuture; //導入方法依賴的package包/類
@Test public void bodyFailure() throws Exception {
  server.enqueue(new MockResponse().setSocketPolicy(DISCONNECT_AFTER_REQUEST));

  CompletableFuture<String> future = service.body();
  try {
    future.get();
    fail();
  } catch (ExecutionException e) {
    assertThat(e.getCause()).isInstanceOf(IOException.class);
  }
}