Interface Storage (2.46.0)

 String bucketName = "my-unique-bucket";
 String blobName1 = "my-blob-name1";
 String blobName2 = "my-blob-name2";
 StorageBatch batch = storage.batch();
 BlobId firstBlob = BlobId.of(bucketName, blobName1);
 BlobId secondBlob = BlobId.of(bucketName, blobName2);
 batch.delete(firstBlob).notify(new BatchResult.Callback<Boolean, StorageException>() {
   public void success(Boolean result) {
     // deleted successfully
   }

   public void error(StorageException exception) {
     // delete failed
   }
 });
 batch.update(BlobInfo.newBuilder(secondBlob).setContentType("text/plain").build());
 StorageBatchResult<Blob> result = batch.get(secondBlob);
 batch.submit();
 Blob blob = result.get(); // returns get result or throws StorageException
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
 ReadableByteChannel readableByteChannel = ...;
 BlobWriteSession blobWriteSession = storage.blobWriteSession(blobInfo, BlobWriteOption.doesNotExist());

 // open the channel for writing
 try (WritableByteChannel writableByteChannel = blobWriteSession.open()) {
   // copy all bytes
   ByteStreams.copy(readableByteChannel, writableByteChannel);
 } catch (IOException e) {
   // handle IOException
 }

 // get the resulting object metadata
 ApiFuture<BlobInfo> resultFuture = blobWriteSession.getResult();
 BlobInfo gen1 = resultFuture.get();
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String sourceBlob1 = "source_blob_1";
 String sourceBlob2 = "source_blob_2";
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 ComposeRequest request = ComposeRequest.newBuilder()
     .setTarget(blobInfo)
     .addSource(sourceBlob1)
     .addSource(sourceBlob2)
     .build();
 Blob blob = storage.compose(request);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String copyBlobName = "copy_blob_name";
 CopyRequest request = CopyRequest.newBuilder()
     .setSource(BlobId.of(bucketName, blobName))
     .setTarget(BlobId.of(bucketName, copyBlobName))
     .build();
 Blob blob = storage.copy(request).getResult();
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String copyBlobName = "copy_blob_name";
 CopyRequest request = CopyRequest.newBuilder()
     .setSource(BlobId.of(bucketName, blobName))
     .setTarget(BlobId.of(bucketName, copyBlobName))
     .build();
 CopyWriter copyWriter = storage.copy(request);
 while (!copyWriter.isDone()) {
   copyWriter.copyChunk();
 }
 Blob blob = copyWriter.getResult();
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String oldEncryptionKey = "old_encryption_key";
 String newEncryptionKey = "new_encryption_key";
 BlobId blobId = BlobId.of(bucketName, blobName);
 CopyRequest request = CopyRequest.newBuilder()
     .setSource(blobId)
     .setSourceOptions(BlobSourceOption.decryptionKey(oldEncryptionKey))
     .setTarget(blobId, BlobTargetOption.encryptionKey(newEncryptionKey))
     .build();
 Blob blob = storage.copy(request).getResult();
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 Blob blob = storage.create(blobInfo, "Hello, World!".getBytes(UTF_8));
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 Blob blob = storage.create(blobInfo, "Hello, World!".getBytes(UTF_8), 7, 5);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 Blob blob = storage.create(blobInfo);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 InputStream content = new ByteArrayInputStream("Hello, World!".getBytes(UTF_8));
 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 Blob blob = storage.create(blobInfo, content);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String encryptionKey = "my_encryption_key";
 InputStream content = new ByteArrayInputStream("Hello, World!".getBytes(UTF_8));

 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId)
     .setContentType("text/plain")
     .build();
 Blob blob = storage.create(blobInfo, content, BlobWriteOption.encryptionKey(encryptionKey));
 

 String bucketName = "my-unique-bucket";
 Bucket bucket = storage.create(BucketInfo.of(bucketName));
 

 String bucketName = "my-unique-bucket";
 Bucket bucket = storage.create(BucketInfo.newBuilder(bucketName)
     // See here for possible values: http://g.co/cloud/storage/docs/storage-classes
     .setStorageClass(StorageClass.COLDLINE)
     // Possible values: http://g.co/cloud/storage/docs/bucket-locations#location-mr
     .setLocation("asia")
     .build());
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
 Acl acl = storage.createAcl(blobId, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
 Acl acl = storage.createAcl(blobId, Acl.of(User.ofAllUsers(), Role.READER));
 

 String bucketName = "my-unique-bucket";
 Acl acl = storage.createAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));
 

 String bucketName = "my-unique-bucket";
 Acl acl = storage.createAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER),
     BucketSourceOption.userProject("myProject"));
 

 String bucketName = "my-unique-bucket";
 Acl acl =
     storage.createDefaultAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));
 

 BlobId blobId = BlobId.of(bucketName, blobName);
 byte[] content = "Hello, world".getBytes(StandardCharsets.UTF_8);
 Hasher hasher = Hashing.crc32c().newHasher().putBytes(content);
 String crc32c = BaseEncoding.base64().encode(Ints.toByteArray(hasher.hash().asInt()));
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setCrc32c(crc32c).build();
 storage.createFrom(blobInfo, new ByteArrayInputStream(content), Storage.BlobWriteOption.crc32cMatch());
 

 String bucketName = "my-unique-bucket";
 String fileName = "readme.txt";
 BlobId blobId = BlobId.of(bucketName, fileName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 storage.createFrom(blobInfo, Paths.get(fileName));
 

 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("video/webm").build();

 Path file = Paths.get("humongous.file");
 storage.createFrom(blobInfo, file, 0);
 

 ServiceAccount serviceAccount = ServiceAccount.of("my-service-account@google.com");

 HmacKey hmacKey = storage.createHmacKey(serviceAccount);

 String secretKey = hmacKey.getSecretKey();
 HmacKey.HmacKeyMetadata metadata = hmacKey.getMetadata();
 

 String bucketName = "my-unique-bucket";
 String topic = "projects/myProject/topics/myTopic"
 NotificationInfo notificationInfo = NotificationInfo.newBuilder(topic)
  .setCustomAttributes(ImmutableMap.of("label1", "value1"))
  .setEventTypes(NotificationInfo.EventType.OBJECT_FINALIZE)
  .setPayloadFormat(NotificationInfo.PayloadFormat.JSON_API_V1)
  .build();
 Notification notification = storage.createNotification(bucketName, notificationInfo);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 boolean deleted = storage.delete(blobId);
 if (deleted) {
   // the blob was deleted
 } else {
   // the blob was not found
 }
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName);
 boolean deleted = storage.delete(blobId, BlobSourceOption.generationMatch(blobGeneration));
 if (deleted) {
   // the blob was deleted
 } else {
   // the blob was not found
 }
 

 String bucketName = "my-unique-bucket";
 String blobName1 = "my-blob-name1";
 String blobName2 = "my-blob-name2";
 BlobId firstBlob = BlobId.of(bucketName, blobName1);
 BlobId secondBlob = BlobId.of(bucketName, blobName2);
 List<Boolean> deleted = storage.delete(firstBlob, secondBlob);
 

 String bucketName = "my-unique-bucket";
 String blobName1 = "my-blob-name1";
 String blobName2 = "my-blob-name2";
 List<BlobId> blobIds = new LinkedList<>();
 blobIds.add(BlobId.of(bucketName, blobName1));
 blobIds.add(BlobId.of(bucketName, blobName2));
 List<Boolean> deleted = storage.delete(blobIds);
 

 String bucketName = "my-unique-bucket";
 long bucketMetageneration = 42;
 boolean deleted = storage.delete(bucketName,
     BucketSourceOption.metagenerationMatch(bucketMetageneration));
 if (deleted) {
   // the bucket was deleted
 } else {
   // the bucket was not found
 }
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 boolean deleted = storage.delete(bucketName, blobName,
     BlobSourceOption.generationMatch(blobGeneration));
 if (deleted) {
   // the blob was deleted
 } else {
   // the blob was not found
 }
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
 boolean deleted = storage.deleteAcl(blobId, User.ofAllAuthenticatedUsers());
 if (deleted) {
   // the acl entry was deleted
 } else {
   // the acl entry was not found
 }
 

 String bucketName = "my-unique-bucket";
 boolean deleted = storage.deleteAcl(bucketName, User.ofAllAuthenticatedUsers());
 if (deleted) {
   // the acl entry was deleted
 } else {
   // the acl entry was not found
 }
 

 String bucketName = "my-unique-bucket";
 BucketSourceOption userProject = BucketSourceOption.userProject("myProject");
 boolean deleted = storage.deleteAcl(bucketName, User.ofAllAuthenticatedUsers(), userProject);
 

 String bucketName = "my-unique-bucket";
 boolean deleted = storage.deleteDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
 if (deleted) {
   // the acl entry was deleted
 } else {
   // the acl entry was not found
 }
 

 String hmacKeyAccessId = "my-access-id";
 HmacKey.HmacKeyMetadata hmacKeyMetadata = storage.getHmacKey(hmacKeyAccessId);

 storage.updateHmacKeyState(hmacKeyMetadata, HmacKey.HmacKeyState.INACTIVE);
 storage.deleteHmacKey(hmacKeyMetadata);
 

 String bucketName = "my-unique-bucket";
 String notificationId = "my-unique-notification-id";
 boolean deleted = storage.deleteNotification(bucketName, notificationId);
 if (deleted) {
   // the notification was deleted
 } else {
   // the notification was not found
 }
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 Path destination = Paths.get("my-blob-destination.txt");
 try (OutputStream outputStream = Files.newOutputStream(path)) {
  downloadTo(blob, outputStream);
  // do stuff with destination
 }
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 Path destination = Paths.get("my-blob-destination.txt");
 downloadTo(blobId, destination);
 // do stuff with destination
 

 PostFieldsV4 fields = PostFieldsV4.newBuilder().setAcl("public-read").build();
 PostConditionsV4 conditions = PostConditionsV4.newBuilder().addContentTypeCondition(ConditionV4Type.MATCHES, "image/jpeg").build();

 PostPolicyV4 policy = storage.generateSignedPostPolicyV4(
     BlobInfo.newBuilder("my-bucket", "my-object").build(),
     7, TimeUnit.DAYS, fields, conditions);

 HttpClient client = HttpClientBuilder.create().build();
 HttpPost request = new HttpPost(policy.getUrl());
 MultipartEntityBuilder builder = MultipartEntityBuilder.create();

 for (Map.Entry<String, String> entry : policy.getFields().entrySet()) {
     builder.addTextBody(entry.getKey(), entry.getValue());
 }
 File file = new File("path/to/your/file/to/upload");
 builder.addBinaryBody("file", new FileInputStream(file), ContentType.APPLICATION_OCTET_STREAM, file.getName());
 request.setEntity(builder.build());
 client.execute(request);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 BlobId blobId = BlobId.of(bucketName, blobName);
 Blob blob = storage.get(blobId);
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobMetageneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName);
 Blob blob = storage.get(blobId, BlobGetOption.metagenerationMatch(blobMetageneration));
 

 String bucketName = "my-unique-bucket";
 String blobName1 = "my-blob-name1";
 String blobName2 = "my-blob-name2";
 BlobId firstBlob = BlobId.of(bucketName, blobName1);
 BlobId secondBlob = BlobId.of(bucketName, blobName2);
 List<Blob> blobs = storage.get(firstBlob, secondBlob);
 

 String bucketName = "my-unique-bucket";
 String blobName1 = "my-blob-name1";
 String blobName2 = "my-blob-name2";
 List<BlobId> blobIds = new LinkedList<>();
 blobIds.add(BlobId.of(bucketName, blobName1));
 blobIds.add(BlobId.of(bucketName, blobName2));
 List<Blob> blobs = storage.get(blobIds);
 

 String bucketName = "my-unique-bucket";
 long bucketMetageneration = 42;
 Bucket bucket = storage.get(bucketName,
     BucketGetOption.metagenerationMatch(bucketMetageneration));
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobMetageneration = 42;
 Blob blob = storage.get(bucketName, blobName,
     BlobGetOption.metagenerationMatch(blobMetageneration));
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 long blobGeneration = 42;
 BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
 Acl acl = storage.getAcl(blobId, User.ofAllAuthenticatedUsers());
 

 String bucketName = "my-unique-bucket";
 String blobName = "my-blob-name";
 String userEmail = "google-cloud-java-tests@java-docs-samples-tests.iam.gserviceaccount.com";
 BlobId blobId = BlobId.of(bucketName, blobName);
 Acl acl = storage.getAcl(blobId, new User(userEmail));
 

 String bucketName = "my-unique-bucket";
 Acl acl = storage.getAcl(bucketName, User.ofAllAuthenticatedUsers());
 

 String bucketName = "my-unique-bucket";
 String userEmail = "google-cloud-java-tests@java-docs-samples-tests.iam.gserviceaccount.com";
 BucketSourceOption userProjectOption = BucketSourceOption.userProject("myProject");
 Acl acl = storage.getAcl(bucketName, new User(userEmail), userProjectOption);
 

 String bucketName = "my-unique-bucket";
 Acl acl = storage.getDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
 

 String hmacKeyAccessId = "my-access-id";
 HmacKey.HmackeyMetadata hmacKeyMetadata = storage.getHmacKey(hmacKeyAccessId);
 

 String bucketName = "my-unique-bucket";
 Policy policy = storage.getIamPolicy(bucketName);