Java ApiFuture类代码示例

import com.google.api.core.ApiFuture; //导入依赖的package包/类
@Test
public void testAddListener() throws Exception {
  Task<String> task = Tasks.forResult("test");
  ApiFuture<String> future = new TaskToApiFuture<>(task);
  final AtomicBoolean result = new AtomicBoolean(false);
  future.addListener(new Runnable() {
    @Override
    public void run() {
      result.set(true);
    }
  }, MoreExecutors.directExecutor());
  assertEquals("test", future.get());
  assertTrue(result.get());
  assertFalse(future.isCancelled());
  assertTrue(future.isDone());
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
@Test
public void testInitAfterAppDelete() throws ExecutionException, InterruptedException,
    TimeoutException {
  FirebaseApp app = FirebaseApp.initializeApp(firebaseOptions, "testInitAfterAppDelete");
  FirebaseAuth auth1 = FirebaseAuth.getInstance(app);
  assertNotNull(auth1);
  app.delete();

  app = FirebaseApp.initializeApp(firebaseOptions, "testInitAfterAppDelete");
  FirebaseAuth auth2 = FirebaseAuth.getInstance(app);
  assertNotNull(auth2);
  assertNotSame(auth1, auth2);

  if (isCertCredential) {
    ApiFuture<String> future = auth2.createCustomTokenAsync("foo");
    assertNotNull(future);
    assertNotNull(future.get(TestUtils.TEST_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
  }
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
void retrieveAllDocuments() throws Exception {
  // [START fs_get_all]
  // asynchronously retrieve all users
  ApiFuture<QuerySnapshot> query = db.collection("users").get();
  // ...
  // query.get() blocks on response
  QuerySnapshot querySnapshot = query.get();
  List<DocumentSnapshot> documents = querySnapshot.getDocuments();
  for (DocumentSnapshot document : documents) {
    System.out.println("User: " + document.getId());
    System.out.println("First: " + document.getString("first"));
    if (document.contains("middle")) {
      System.out.println("Middle: " + document.getString("middle"));
    }
    System.out.println("Last: " + document.getString("last"));
    System.out.println("Born: " + document.getLong("born"));
  }
  // [END fs_get_all]
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/**
 * Creates a sample query.
 *
 * @return query
 */
Query createAQuery() throws Exception {
  // [START fs_create_query]
  // Create a reference to the cities collection
  CollectionReference cities = db.collection("cities");
  // Create a query against the collection.
  Query query = cities.whereEqualTo("capital", true);
  // retrieve  query results asynchronously using query.get()
  ApiFuture<QuerySnapshot> querySnapshot = query.get();

  for (DocumentSnapshot document : querySnapshot.get().getDocuments()) {
    System.out.println(document.getId());
  }
  // [END fs_create_query]
  return query;
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/**
 * Creates a sample query.
 *
 * @return query
 */
Query createAQueryAlternate() throws Exception {
  // [START fs_create_query_country]
  // Create a reference to the cities collection
  CollectionReference cities = db.collection("cities");
  // Create a query against the collection.
  Query query = cities.whereEqualTo("state", "CA");
  // retrieve  query results asynchronously using query.get()
  ApiFuture<QuerySnapshot> querySnapshot = query.get();

  for (DocumentSnapshot document : querySnapshot.get().getDocuments()) {
    System.out.println(document.getId());
  }
  // [END fs_create_query_country]
  return query;
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/**
 * Add a document to a collection using a map.
 *
 * @return document data
 */
Map<String, Object> addSimpleDocumentAsMap() throws Exception {
  // [START fs_add_doc_as_map]
  // Create a Map to store the data we want to set
  Map<String, Object> docData = new HashMap<>();
  docData.put("name", "Los Angeles");
  docData.put("state", "CA");
  docData.put("country", "USA");
  // Add a new document (asynchronously) in collection "cities" with id "LA"
  ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(docData);
  // ...
  // future.get() blocks on response
  System.out.println("Update time : " + future.get().getUpdateTime());
  // [END fs_add_doc_as_map]
  return docData;
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/**
 * Add a document to a collection using a map with different supported data types.
 *
 * @return document data
 */
Map<String, Object> addDocumentWithDifferentDataTypes() throws Exception {
  // [START fs_add_doc_data_types]
  Map<String, Object> docData = new HashMap<>();
  docData.put("stringExample", "Hello, World");
  docData.put("booleanExample", false);
  docData.put("numberExample", 3.14159265);
  docData.put("nullExample", null);

  ArrayList<Object> arrayExample = new ArrayList<>();
  Collections.addAll(arrayExample, 5L, true, "hello");
  docData.put("arrayExample", arrayExample);

  Map<String, Object> objectExample = new HashMap<>();
  objectExample.put("a", 5L);
  objectExample.put("b", true);

  docData.put("objectExample", objectExample);

  ApiFuture<WriteResult> future = db.collection("data").document("one").set(docData);
  System.out.println("Update time : " + future.get().getUpdateTime());
  // [END fs_add_doc_data_types]

  return docData;
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/**
 * Add data to a document after generating the document id.
 *
 * @return auto generated id
 */
String addDocumentDataAfterAutoGeneratingId() throws Exception {
  City data = new City();

  // [START fs_add_doc_data_after_auto_id]
  // Add document data after generating an id.
  DocumentReference addedDocRef = db.collection("cities").document();
  System.out.println("Added document with ID: " + addedDocRef.getId());

  // later...
  ApiFuture<WriteResult> writeResult = addedDocRef.set(data);
  // [END fs_add_doc_data_after_auto_id]

  // writeResult.get() blocks on operation
  System.out.println("Update time : " + writeResult.get().getUpdateTime());
  return addedDocRef.getId();
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/** Partially update fields of a document using a map (field => value). */
void updateUsingMap() throws Exception {
  db.collection("cities").document("DC").set(new City("Washington D.C.")).get();
  // [START fs_update_doc_map]
  // update multiple fields using a map
  DocumentReference docRef = db.collection("cities").document("DC");

  Map<String, Object> updates = new HashMap<>();
  updates.put("name", "Washington D.C.");
  updates.put("country", "USA");
  updates.put("capital", true);

  //asynchronously update doc
  ApiFuture<WriteResult> writeResult = docRef.update(updates);
  // ...
  System.out.println("Update time : " + writeResult.get().getUpdateTime());
  // [END fs_update_doc_map]
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/** Partially update fields of a document using a map (field => value). */
void updateAndCreateIfMissing() throws Exception {
  // [START fs_update_create_if_missing]
  //asynchronously update doc, create the document if missing
  Map<String, Object> update = new HashMap<>();
  update.put("capital", true);

  ApiFuture<WriteResult> writeResult =
      db
          .collection("cities")
          .document("BJ")
          .set(update, SetOptions.merge());
  // ...
  System.out.println("Update time : " + writeResult.get().getUpdateTime());
  // [END fs_update_create_if_missing]
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
/** Delete a collection in batches to avoid out-of-memory errors.
 * Batch size may be tuned based on document size (atmost 1MB) and application requirements.
 */
void deleteCollection(CollectionReference collection, int batchSize) {
  try {
    // retrieve a small batch of documents to avoid out-of-memory errors
    ApiFuture<QuerySnapshot> future = collection.limit(batchSize).get();
    int deleted = 0;
    // future.get() blocks on document retrieval
    List<DocumentSnapshot> documents = future.get().getDocuments();
    for (DocumentSnapshot document : documents) {
      document.getReference().delete();
      ++deleted;
    }
    if (deleted >= batchSize) {
      // retrieve and delete another batch
      deleteCollection(collection, batchSize);
    }
  } catch (Exception e) {
    System.err.println("Error deleting collection : " + e.getMessage());
  }
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
private void publish(Record record) throws StageException {
  ByteArrayOutputStream os = new ByteArrayOutputStream();
  try (DataGenerator generator = generatorFactory.getGenerator(os)) {
    generator.write(record);
  } catch (IOException | DataGeneratorException e) {
    errorRecordHandler.onError(new OnRecordErrorException(record, Errors.PUBSUB_06, e.toString(), e));
    return;
  }

  ByteString data = ByteString.copyFrom(os.toByteArray());

  Map<String, String> attributes = new HashMap<>();
  Record.Header header = record.getHeader();
  header.getAttributeNames().forEach(k -> attributes.put(k, header.getAttribute(k)));

  PubsubMessage message = PubsubMessage.newBuilder().setData(data).putAllAttributes(attributes).build();

  ApiFuture<String> messageIdFuture = publisher.publish(message);
  pendingMessages.add(new PendingMessage(record, messageIdFuture));
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
@Test
public void testGetResult() throws Exception {
  Task<String> task = Tasks.forResult("test");
  ApiFuture<String> future = new TaskToApiFuture<>(task);
  assertEquals("test", future.get());
  assertFalse(future.isCancelled());
  assertTrue(future.isDone());
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
@Test
public void testGetError() throws Exception {
  Task<String> task = Tasks.forException(new RuntimeException("test"));
  ApiFuture<String> future = new TaskToApiFuture<>(task);
  try {
    future.get();
  } catch (ExecutionException e) {
    assertEquals("test", e.getCause().getMessage());
  }
  assertFalse(future.isCancelled());
  assertTrue(future.isDone());
}
 

import com.google.api.core.ApiFuture; //导入依赖的package包/类
@Test
public void testCancel() throws Exception {
  Task<String> task = Tasks.forResult("test");
  ApiFuture<String> future = new TaskToApiFuture<>(task);
  assertFalse(future.cancel(true));
  assertEquals("test", future.get());
  assertFalse(future.isCancelled());
  assertTrue(future.isDone());
}