Java S3Objects.withPrefix方法代码示例

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
@Override
public Stream<WriteableConfiguration> getCachedConfigurations() throws IOException {

  Iterable<S3ObjectSummary> objectSummaries = S3Objects.withPrefix(s3, bucket, prefix);
  Stream<S3ObjectSummary> objectStream = StreamSupport.stream(objectSummaries.spliterator(), false);

  return objectStream.map(p -> {
    Integer version = getVersionIfMatch(p.getKey());
    if (version == null) {
      return null;
    }
    return new Pair<>(version, p);
  }).filter(Objects::nonNull)
      .sorted(Comparator.comparing(pair -> ((Pair<Integer, S3ObjectSummary>) pair).getFirst())
            .reversed()).map(pair -> new S3WritableConfiguration(s3, pair.getSecond(), Integer.toString(pair.getFirst())));

}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
static void deletePrefix(AmazonS3 s3Client, String bucketName, String prefix) {
    List<DeleteObjectsRequest.KeyVersion> trashKeys = new ArrayList<>();
    DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
    for (S3ObjectSummary summary: S3Objects.withPrefix(s3Client, bucketName, prefix)) {
        trashKeys.add(new DeleteObjectsRequest.KeyVersion(summary.getKey()));
        if (trashKeys.size() == BULK_DELETE_SIZE) {
            deleteObjectsRequest.setKeys(trashKeys);
            s3Client.deleteObjects(deleteObjectsRequest);
            trashKeys.clear();
        }
    }
    if (!trashKeys.isEmpty()) {
        deleteObjectsRequest.setKeys(trashKeys);
        s3Client.deleteObjects(deleteObjectsRequest);
    }
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
@Override
protected void copy(RuntimeExecutionTrace source, RuntimeExecutionTrace target,
        RuntimeAnnotatedExecutionTrace absoluteSource, RuntimeAnnotatedExecutionTrace absoluteTarget)
        throws IOException {
    String sourcePrefix = toS3Path(source).getPrefixForChildren();
    String targetPrefix = toS3Path(target).getPrefixForChildren();
    for (S3ObjectSummary summary: S3Objects.withPrefix(s3Client, bucketName, sourcePrefix)) {
        if (summary.getKey().startsWith(sourcePrefix)) {
            String relativeKey = summary.getKey().substring(sourcePrefix.length());
            s3Client.copyObject(bucketName, summary.getKey(), bucketName, targetPrefix + relativeKey);
        } else {
            log.error(String.format(
                "S3Objects.withPrefix() returned unexpected key '%s' when asked for prefix '%s'.",
                summary.getKey(), sourcePrefix
            ));
        }
    }
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
	DeleteBucketRequest deleteBucketRequest=new DeleteBucketRequest(AWSResources.S3_BUCKET_NAME);
	if(AWSResources.S3.doesBucketExist(AWSResources.S3_BUCKET_NAME))
		try {
				AWSResources.S3.deleteBucket(deleteBucketRequest);
				System.out.println("Bucket Deleted...");
		}
	catch (AmazonS3Exception ex) {
		if(!ex.getErrorCode().equals("BucketNotEmpty"))
			throw ex;
	}
	//List<KeyVersion> keys = new ArrayList<KeyVersion>();
	for(S3ObjectSummary obj : S3Objects.withPrefix(AWSResources.S3, AWSResources.S3_BUCKET_NAME, "")) {
    // Add the keys to our list of object.
    AWSResources.S3.deleteObject(AWSResources.S3_BUCKET_NAME, obj.getKey());
	}
	//DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(AWSResources.S3_BUCKET_NAME);
	//AWSResources.S3.deleteObjects(deleteObjectsRequest);
	AWSResources.S3.deleteBucket(deleteBucketRequest);
	if(!AWSResources.S3.doesBucketExist(AWSResources.S3_BUCKET_NAME))
		System.out.println("Deleted");
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
@Override
public Stream<BlobId> getBlobIdStream() {
  Iterable<S3ObjectSummary> summaries = S3Objects.withPrefix(s3, getConfiguredBucket(), CONTENT_PREFIX);
  return StreamSupport.stream(summaries.spliterator(), false)
    .map(S3ObjectSummary::getKey)
    .map(key -> key.substring(key.lastIndexOf('/') + 1, key.length()))
    .filter(filename -> filename.endsWith(BLOB_ATTRIBUTE_SUFFIX) && !filename.startsWith(TEMPORARY_BLOB_ID_PREFIX))
    .map(filename -> filename.substring(0, filename.length() - BLOB_ATTRIBUTE_SUFFIX.length()))
    .map(BlobId::new);
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
static S3ObjectSummary getObjectSummary(AmazonS3 s3Client, String bucket, String objectKey) {
  S3ObjectSummary s3ObjectSummary = null;
  S3Objects s3ObjectSummaries = S3Objects.withPrefix(s3Client, bucket, objectKey);
  for (S3ObjectSummary s : s3ObjectSummaries) {
    if (s.getKey().equals(objectKey)) {
      s3ObjectSummary = s;
      break;
    }
  }
  return s3ObjectSummary;
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
private Map<Pair<String, String>, S3ObjectSummary> getObjectSummaries(AmazonS3 s3Client, String bucket, String prefix) {
  Map<Pair<String, String>, S3ObjectSummary> s3ObjectSummaries = new HashMap<>();
  for(S3ObjectSummary s : S3Objects.withPrefix(s3Client, bucket, prefix)) {
    s3ObjectSummaries.put(Pair.of(bucket, s.getKey()), s);
  }
  return s3ObjectSummaries;
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
private int getObjectCount(AmazonS3 s3Client, String bucket, String prefix) {
  int count = 0;
  for(S3ObjectSummary ignored : S3Objects.withPrefix(s3Client, bucket, prefix)) {
    count++;
  }
  return count;
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
private void start() throws IOException, InterruptedException {
    AmazonS3Client s3Client = new AmazonS3Client();

    S3Objects s3Objects = S3Objects.withPrefix(s3Client, config.getS3Bucket(), config.getS3Key());

    final ElasticWriter elasticWriter = new ElasticWriter(config.getElasticIndexName(), config.getElasticHost(), config.getElasticPort());

    int count = 0;
    for (S3ObjectSummary s3ObjectSummary : s3Objects) {
        s3ObjectSummary.getKey();

        S3Object object = s3Client.getObject(s3ObjectSummary.getBucketName(), s3ObjectSummary.getKey());
        log.info("Downloading content of: {}", object.getKey());

        S3ObjectInputStream objectContentStream = object.getObjectContent();

        BufferedReader reader = new BufferedReader(new InputStreamReader(objectContentStream));

        String line = null;
        while ((line = reader.readLine()) != null) {
            Scanner scanner = new Scanner(line).useDelimiter("\t");

            String t1 = scanner.next();
            String t2 = scanner.next();
            Integer value = scanner.nextInt();

            elasticWriter.write(t1, t2, value);
            count++;
        }

        log.info("Wrote {} pairs", count);
    }
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
@Override
public Stream<BlobId> getBlobIdStream() {
  Iterable<S3ObjectSummary> summaries = S3Objects.withPrefix(s3, getConfiguredBucket(), CONTENT_PREFIX);
  return blobIdStream(summaries);
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
@Override
public Stream<BlobId> getDirectPathBlobIdStream(final String prefix) {
  String subpath = format("%s/%s/%s", CONTENT_PREFIX, DIRECT_PATH_ROOT, prefix);
  Iterable<S3ObjectSummary> summaries = S3Objects.withPrefix(s3, getConfiguredBucket(), subpath);
  return blobIdStream(summaries);
}
 

import com.amazonaws.services.s3.iterable.S3Objects; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
	for (S3ObjectSummary summary : S3Objects.withPrefix(AWSResources.S3, AWSResources.S3_BUCKET_NAME, "photos/")) {
		System.out.printf("Object with key '%s'\n", summary.getKey());
	}
}